Merge remote-tracking branch 'upstream/mueller/refactor-tmtc-stack' into mueller/tmtc-stack-refactoring

2022-08-15 11:30:09 +02:00 · 2022-08-15 11:30:09 +02:00 · d022ce82c5
parent b28091e05b 9796abfc7d
commit d022ce82c5
281 changed files with 7127 additions and 4626 deletions
--- a/automation/Jenkinsfile
+++ b/automation/Jenkinsfile
@ -1,6 +1,6 @@
 pipeline {
    environment {
-        BUILDDIR = 'build-tests'
+        BUILDDIR = 'cmake-build-tests'
    }
    agent {
        docker { image 'fsfw-ci:d3'}
--- a/misc/defaultcfg/fsfwconfig/objects/FsfwFactory.cpp
+++ b/misc/defaultcfg/fsfwconfig/objects/FsfwFactory.cpp
@ -36,7 +36,7 @@ void Factory::produceFsfwObjects(void) {

 void Factory::setStaticFrameworkObjectIds() {
 	PusServiceBase::packetSource = objects::NO_OBJECT;
-	PusServiceBase::packetDestination = objects::NO_OBJECT;
+	PusServiceBase::PACKET_DESTINATION = objects::NO_OBJECT;

 	CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
 	CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
--- a/scripts/helper.py
+++ b/scripts/helper.py
@ -13,7 +13,7 @@ from shutil import which
 from typing import List


-UNITTEST_FOLDER_NAME = "build-tests"
+UNITTEST_FOLDER_NAME = "cmake-build-tests"
 DOCS_FOLDER_NAME = "build-docs"


--- a/src/fsfw/cfdp/CFDPMessage.cpp
+++ b/src/fsfw/cfdp/CFDPMessage.cpp
@ -1,17 +0,0 @@
-#include "CFDPMessage.h"
-
-CFDPMessage::CFDPMessage() {}
-
-CFDPMessage::~CFDPMessage() {}
-
-void CFDPMessage::setCommand(CommandMessage *message, store_address_t cfdpPacket) {
-  message->setParameter(cfdpPacket.raw);
-}
-
-store_address_t CFDPMessage::getStoreId(const CommandMessage *message) {
-  store_address_t storeAddressCFDPPacket;
-  storeAddressCFDPPacket = message->getParameter();
-  return storeAddressCFDPPacket;
-}
-
-void CFDPMessage::clear(CommandMessage *message) {}
--- a/src/fsfw/cfdp/CMakeLists.txt
+++ b/src/fsfw/cfdp/CMakeLists.txt
@ -1,4 +1,4 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE CFDPHandler.cpp CFDPMessage.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE CfdpHandler.cpp CfdpMessage.cpp)

 add_subdirectory(pdu)
 add_subdirectory(tlv)
--- a/src/fsfw/cfdp/CfdpHandler.cpp
+++ b/src/fsfw/cfdp/CfdpHandler.cpp
@ -1,16 +1,16 @@
-#include "fsfw/cfdp/CFDPHandler.h"
+#include "fsfw/cfdp/CfdpHandler.h"

-#include "fsfw/cfdp/CFDPMessage.h"
+#include "fsfw/cfdp/CfdpMessage.h"
 #include "fsfw/ipc/CommandMessage.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/storagemanager/storeAddress.h"
 #include "fsfw/tmtcservices/AcceptsTelemetryIF.h"

-object_id_t CFDPHandler::packetSource = 0;
-object_id_t CFDPHandler::packetDestination = 0;
+object_id_t CfdpHandler::packetSource = 0;
+object_id_t CfdpHandler::packetDestination = 0;

-CFDPHandler::CFDPHandler(object_id_t setObjectId, CFDPDistributor* dist)
+CfdpHandler::CfdpHandler(object_id_t setObjectId, CFDPDistributor* dist)
    : SystemObject(setObjectId) {
  auto mqArgs = MqArgs(setObjectId, static_cast<void*>(this));
  requestQueue = QueueFactory::instance()->createMessageQueue(
@ -18,9 +18,9 @@ CFDPHandler::CFDPHandler(object_id_t setObjectId, CFDPDistributor* dist)
  distributor = dist;
 }

-CFDPHandler::~CFDPHandler() {}
+CfdpHandler::~CfdpHandler() = default;

-ReturnValue_t CFDPHandler::initialize() {
+ReturnValue_t CfdpHandler::initialize() {
  ReturnValue_t result = SystemObject::initialize();
  if (result != RETURN_OK) {
    return result;
@ -29,7 +29,7 @@ ReturnValue_t CFDPHandler::initialize() {
  return HasReturnvaluesIF::RETURN_OK;
 }

-ReturnValue_t CFDPHandler::handleRequest(store_address_t storeId) {
+ReturnValue_t CfdpHandler::handleRequest(store_address_t storeId) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
  sif::debug << "CFDPHandler::handleRequest" << std::endl;
@ -43,17 +43,17 @@ ReturnValue_t CFDPHandler::handleRequest(store_address_t storeId) {
  return RETURN_OK;
 }

-ReturnValue_t CFDPHandler::performOperation(uint8_t opCode) {
+ReturnValue_t CfdpHandler::performOperation(uint8_t opCode) {
  ReturnValue_t status = RETURN_OK;
  CommandMessage currentMessage;
  for (status = this->requestQueue->receiveMessage(&currentMessage); status == RETURN_OK;
       status = this->requestQueue->receiveMessage(&currentMessage)) {
-    store_address_t storeId = CFDPMessage::getStoreId(&currentMessage);
+    store_address_t storeId = CfdpMessage::getStoreId(&currentMessage);
    this->handleRequest(storeId);
  }
  return RETURN_OK;
 }

-uint16_t CFDPHandler::getIdentifier() { return 0; }
+uint16_t CfdpHandler::getIdentifier() { return 0; }

-MessageQueueId_t CFDPHandler::getRequestQueue() { return this->requestQueue->getId(); }
+MessageQueueId_t CfdpHandler::getRequestQueue() { return this->requestQueue->getId(); }
--- a/src/fsfw/cfdp/CfdpHandler.h
+++ b/src/fsfw/cfdp/CfdpHandler.h
@ -12,18 +12,18 @@ namespace Factory {
 void setStaticFrameworkObjectIds();
 }

-class CFDPHandler : public ExecutableObjectIF,
+class CfdpHandler : public ExecutableObjectIF,
                    public AcceptsTelecommandsIF,
                    public SystemObject,
                    public HasReturnvaluesIF {
  friend void(Factory::setStaticFrameworkObjectIds)();

 public:
-  CFDPHandler(object_id_t setObjectId, CFDPDistributor* distributor);
+  CfdpHandler(object_id_t setObjectId, CFDPDistributor* distributor);
  /**
   * The destructor is empty.
   */
-  virtual ~CFDPHandler();
+  virtual ~CfdpHandler();

  virtual ReturnValue_t handleRequest(store_address_t storeId);

@ -45,7 +45,7 @@ class CFDPHandler : public ExecutableObjectIF,
   * The current CFDP packet to be processed.
   * It is deleted after handleRequest was executed.
   */
-  CFDPPacketStored currentPacket;
+  CfdpPacketStored currentPacket;

  static object_id_t packetSource;

--- a/src/fsfw/cfdp/CfdpMessage.cpp
+++ b/src/fsfw/cfdp/CfdpMessage.cpp
@ -0,0 +1,17 @@
+#include "CfdpMessage.h"
+
+CfdpMessage::CfdpMessage() = default;
+
+CfdpMessage::~CfdpMessage() = default;
+
+void CfdpMessage::setCommand(CommandMessage *message, store_address_t cfdpPacket) {
+  message->setParameter(cfdpPacket.raw);
+}
+
+store_address_t CfdpMessage::getStoreId(const CommandMessage *message) {
+  store_address_t storeId;
+  storeId = static_cast<store_address_t>(message->getParameter());
+  return storeId;
+}
+
+void CfdpMessage::clear(CommandMessage *message) {}
--- a/src/fsfw/cfdp/CfdpMessage.h
+++ b/src/fsfw/cfdp/CfdpMessage.h
@ -5,14 +5,14 @@
 #include "fsfw/objectmanager/ObjectManagerIF.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"

-class CFDPMessage {
+class CfdpMessage {
 private:
-  CFDPMessage();
+  CfdpMessage();

 public:
  static const uint8_t MESSAGE_ID = messagetypes::CFDP;

-  virtual ~CFDPMessage();
+  virtual ~CfdpMessage();
  static void setCommand(CommandMessage* message, store_address_t cfdpPacket);

  static store_address_t getStoreId(const CommandMessage* message);
--- a/src/fsfw/cfdp/definitions.h
+++ b/src/fsfw/cfdp/definitions.h
@ -15,28 +15,21 @@ static constexpr uint8_t VERSION_BITS = 0b00100000;

 static constexpr uint8_t CFDP_CLASS_ID = CLASS_ID::CFDP;

-static constexpr ReturnValue_t INVALID_TLV_TYPE =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 1);
-static constexpr ReturnValue_t INVALID_DIRECTIVE_FIELDS =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 2);
-static constexpr ReturnValue_t INVALID_PDU_DATAFIELD_LEN =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 3);
-static constexpr ReturnValue_t INVALID_ACK_DIRECTIVE_FIELDS =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 4);
+static constexpr ReturnValue_t INVALID_TLV_TYPE = result::makeCode(CFDP_CLASS_ID, 1);
+static constexpr ReturnValue_t INVALID_DIRECTIVE_FIELDS = result::makeCode(CFDP_CLASS_ID, 2);
+static constexpr ReturnValue_t INVALID_PDU_DATAFIELD_LEN = result::makeCode(CFDP_CLASS_ID, 3);
+static constexpr ReturnValue_t INVALID_ACK_DIRECTIVE_FIELDS = result::makeCode(CFDP_CLASS_ID, 4);
 //! Can not parse options. This can also occur because there are options
 //! available but the user did not pass a valid options array
-static constexpr ReturnValue_t METADATA_CANT_PARSE_OPTIONS =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 5);
-static constexpr ReturnValue_t NAK_CANT_PARSE_OPTIONS =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 6);
+static constexpr ReturnValue_t METADATA_CANT_PARSE_OPTIONS = result::makeCode(CFDP_CLASS_ID, 5);
+static constexpr ReturnValue_t NAK_CANT_PARSE_OPTIONS = result::makeCode(CFDP_CLASS_ID, 6);
 static constexpr ReturnValue_t FINISHED_CANT_PARSE_FS_RESPONSES =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 6);
-static constexpr ReturnValue_t FILESTORE_REQUIRES_SECOND_FILE =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 8);
+    result::makeCode(CFDP_CLASS_ID, 6);
+static constexpr ReturnValue_t FILESTORE_REQUIRES_SECOND_FILE = result::makeCode(CFDP_CLASS_ID, 8);
 //! Can not parse filestore response because user did not pass a valid instance
 //! or remaining size is invalid
 static constexpr ReturnValue_t FILESTORE_RESPONSE_CANT_PARSE_FS_MESSAGE =
-    HasReturnvaluesIF::makeReturnCode(CFDP_CLASS_ID, 9);
+    result::makeCode(CFDP_CLASS_ID, 9);

 //! Checksum types according to the SANA Checksum Types registry
 //! https://sanaregistry.org/r/checksum_identifiers/
--- a/src/fsfw/datalinklayer/MapPacketExtraction.cpp
+++ b/src/fsfw/datalinklayer/MapPacketExtraction.cpp
@ -6,7 +6,7 @@
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
-#include "fsfw/tmtcpacket/SpacePacketBase.h"
+#include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
 #include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
 #include "fsfw/tmtcservices/TmTcMessage.h"

--- a/src/fsfw/datapoollocal/HasLocalDataPoolIF.h
+++ b/src/fsfw/datapoollocal/HasLocalDataPoolIF.h
@ -79,8 +79,7 @@ class HasLocalDataPoolIF {
   * @param clearMessage  If this is set to true, the pool manager will take care of
   *                      clearing the store automatically
   */
-  virtual void handleChangedDataset(sid_t sid,
-                                    store_address_t storeId = storeId::INVALID_STORE_ADDRESS,
+  virtual void handleChangedDataset(sid_t sid, store_address_t storeId = store_address_t::invalid(),
                                    bool* clearMessage = nullptr) {
    if (clearMessage != nullptr) {
      *clearMessage = true;
@ -100,7 +99,7 @@ class HasLocalDataPoolIF {
   *                      after the callback.
   */
  virtual void handleChangedPoolVariable(gp_id_t gpid,
-                                         store_address_t storeId = storeId::INVALID_STORE_ADDRESS,
+                                         store_address_t storeId = store_address_t::invalid(),
                                         bool* clearMessage = nullptr) {
    if (clearMessage != nullptr) {
      *clearMessage = true;
--- a/src/fsfw/datapoollocal/LocalDataPoolManager.cpp
+++ b/src/fsfw/datapoollocal/LocalDataPoolManager.cpp
@ -1,6 +1,5 @@
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"

-#include <array>
 #include <cmath>

 #include "fsfw/datapoollocal.h"
@ -15,6 +14,7 @@
 #include "internal/HasLocalDpIFManagerAttorney.h"
 #include "internal/LocalPoolDataSetAttorney.h"

+// TODO: Get rid of this. This should be a constructor argument, not something hardcoded in any way
 object_id_t LocalDataPoolManager::defaultHkDestination = objects::PUS_SERVICE_3_HOUSEKEEPING;

 LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
@ -57,7 +57,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
  }

  if (defaultHkDestination != objects::NO_OBJECT) {
-    AcceptsHkPacketsIF* hkPacketReceiver =
+    auto* hkPacketReceiver =
        ObjectManager::instance()->get<AcceptsHkPacketsIF>(defaultHkDestination);
    if (hkPacketReceiver != nullptr) {
      hkDestinationId = hkPacketReceiver->getHkQueue();
@ -209,9 +209,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
    }

    /* Prepare and send update snapshot */
-    timeval now;
+    timeval now{};
    Clock::getClock_timeval(&now);
-    CCSDSTime::CDS_short cds;
+    CCSDSTime::CDS_short cds{};
    CCSDSTime::convertToCcsds(&cds, &now);
    HousekeepingSnapshot updatePacket(
        reinterpret_cast<uint8_t*>(&cds), sizeof(cds),
@ -245,9 +245,9 @@ ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& recei
    }

    /* Prepare and send update snapshot */
-    timeval now;
+    timeval now{};
    Clock::getClock_timeval(&now);
-    CCSDSTime::CDS_short cds;
+    CCSDSTime::CDS_short cds{};
    CCSDSTime::convertToCcsds(&cds, &now);
    HousekeepingSnapshot updatePacket(
        reinterpret_cast<uint8_t*>(&cds), sizeof(cds),
@ -291,12 +291,7 @@ ReturnValue_t LocalDataPoolManager::addUpdateToStore(HousekeepingSnapshot& updat

 void LocalDataPoolManager::handleChangeResetLogic(DataType type, DataId dataId,
                                                  MarkChangedIF* toReset) {
-  if (hkUpdateResetList == nullptr) {
-    /* Config error */
-    return;
-  }
-  HkUpdateResetList& listRef = *hkUpdateResetList;
-  for (auto& changeInfo : listRef) {
+  for (auto& changeInfo : hkUpdateResetList) {
    if (changeInfo.dataType != type) {
      continue;
    }
@ -326,38 +321,37 @@ void LocalDataPoolManager::handleChangeResetLogic(DataType type, DataId dataId,
 }

 void LocalDataPoolManager::resetHkUpdateResetHelper() {
-  if (hkUpdateResetList == nullptr) {
-    return;
-  }
-
-  for (auto& changeInfo : *hkUpdateResetList) {
+  for (auto& changeInfo : hkUpdateResetList) {
    changeInfo.currentUpdateCounter = changeInfo.updateCounter;
  }
 }

-ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
-                                                               float collectionInterval,
-                                                               bool isDiagnostics,
-                                                               object_id_t packetDestination) {
-  AcceptsHkPacketsIF* hkReceiverObject =
-      ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
-  if (hkReceiverObject == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "subscribeForPeriodicPacket",
-                        QUEUE_OR_DESTINATION_INVALID);
-    return QUEUE_OR_DESTINATION_INVALID;
-  }
+ReturnValue_t LocalDataPoolManager::subscribeForRegularPeriodicPacket(
+    subdp::RegularHkPeriodicParams params) {
+  return subscribeForPeriodicPacket(params);
+}

+ReturnValue_t LocalDataPoolManager::subscribeForDiagPeriodicPacket(
+    subdp::DiagnosticsHkPeriodicParams params) {
+  return subscribeForPeriodicPacket(params);
+}
+
+ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(subdp::ParamsBase& params) {
  struct HkReceiver hkReceiver;
-  hkReceiver.dataId.sid = sid;
+  hkReceiver.dataId.sid = params.sid;
  hkReceiver.reportingType = ReportingType::PERIODIC;
  hkReceiver.dataType = DataType::DATA_SET;
-  hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+  if (params.receiver == MessageQueueIF::NO_QUEUE) {
+    hkReceiver.destinationQueue = hkDestinationId;
+  } else {
+    hkReceiver.destinationQueue = params.receiver;
+  }

-  LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+  LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, params.sid);
  if (dataSet != nullptr) {
-    LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enableReporting);
-    LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
-    LocalPoolDataSetAttorney::initializePeriodicHelper(*dataSet, collectionInterval,
+    LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, params.enableReporting);
+    LocalPoolDataSetAttorney::setDiagnostic(*dataSet, params.isDiagnostics());
+    LocalPoolDataSetAttorney::initializePeriodicHelper(*dataSet, params.collectionInterval,
                                                       owner->getPeriodicOperationFrequency());
  }

@ -365,27 +359,30 @@ ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid, bool e
  return HasReturnvaluesIF::RETURN_OK;
 }

-ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(sid_t sid, bool isDiagnostics,
-                                                             bool reportingEnabled,
-                                                             object_id_t packetDestination) {
-  AcceptsHkPacketsIF* hkReceiverObject =
-      ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
-  if (hkReceiverObject == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "subscribeForPeriodicPacket",
-                        QUEUE_OR_DESTINATION_INVALID);
-    return QUEUE_OR_DESTINATION_INVALID;
-  }
+ReturnValue_t LocalDataPoolManager::subscribeForRegularUpdatePacket(
+    subdp::RegularHkUpdateParams params) {
+  return subscribeForUpdatePacket(params);
+}
+ReturnValue_t LocalDataPoolManager::subscribeForDiagUpdatePacket(
+    subdp::DiagnosticsHkUpdateParams params) {
+  return subscribeForUpdatePacket(params);
+}

+ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(subdp::ParamsBase& params) {
  struct HkReceiver hkReceiver;
-  hkReceiver.dataId.sid = sid;
+  hkReceiver.dataId.sid = params.sid;
  hkReceiver.reportingType = ReportingType::UPDATE_HK;
  hkReceiver.dataType = DataType::DATA_SET;
-  hkReceiver.destinationQueue = hkReceiverObject->getHkQueue();
+  if (params.receiver == MessageQueueIF::NO_QUEUE) {
+    hkReceiver.destinationQueue = hkDestinationId;
+  } else {
+    hkReceiver.destinationQueue = params.receiver;
+  }

-  LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
+  LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, params.sid);
  if (dataSet != nullptr) {
    LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, true);
-    LocalPoolDataSetAttorney::setDiagnostic(*dataSet, isDiagnostics);
+    LocalPoolDataSetAttorney::setDiagnostic(*dataSet, params.isDiagnostics());
  }

  hkReceivers.push_back(hkReceiver);
@ -436,11 +433,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessage(
 }

 void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType, DataId dataId) {
-  if (hkUpdateResetList == nullptr) {
-    hkUpdateResetList = new std::vector<struct HkUpdateResetHelper>();
-  }
-
-  for (auto& updateResetStruct : *hkUpdateResetList) {
+  for (auto& updateResetStruct : hkUpdateResetList) {
    if (dataType == DataType::DATA_SET) {
      if (updateResetStruct.dataId.sid == dataId.sid) {
        updateResetStruct.updateCounter++;
@ -464,7 +457,7 @@ void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType, D
  } else {
    hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
  }
-  hkUpdateResetList->push_back(hkUpdateResetHelper);
+  hkUpdateResetList.push_back(hkUpdateResetHelper);
 }

 ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* message) {
@ -643,6 +636,7 @@ ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
      /* Error, all destinations invalid */
      printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket",
                          QUEUE_OR_DESTINATION_INVALID);
+      return QUEUE_OR_DESTINATION_INVALID;
    }
    destination = hkDestinationId;
  }
@ -821,9 +815,7 @@ void LocalDataPoolManager::clearReceiversList() {
  /* Clear the vector completely and releases allocated memory. */
  HkReceivers().swap(hkReceivers);
  /* Also clear the reset helper if it exists */
-  if (hkUpdateResetList != nullptr) {
-    HkUpdateResetList().swap(*hkUpdateResetList);
-  }
+  HkUpdateResetList().swap(hkUpdateResetList);
 }

 MutexIF* LocalDataPoolManager::getLocalPoolMutex() { return this->mutex; }
@ -885,3 +877,7 @@ void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
 }

 LocalDataPoolManager* LocalDataPoolManager::getPoolManagerHandle() { return this; }
+
+void LocalDataPoolManager::setHkDestinationId(MessageQueueId_t hkDestId) {
+  hkDestinationId = hkDestId;
+}
--- a/src/fsfw/datapoollocal/LocalDataPoolManager.h
+++ b/src/fsfw/datapoollocal/LocalDataPoolManager.h
@ -8,6 +8,7 @@
 #include "ProvidesDataPoolSubscriptionIF.h"
 #include "fsfw/datapool/DataSetIF.h"
 #include "fsfw/datapool/PoolEntry.h"
+#include "fsfw/housekeeping/AcceptsHkPacketsIF.h"
 #include "fsfw/housekeeping/HousekeepingMessage.h"
 #include "fsfw/housekeeping/HousekeepingPacketDownlink.h"
 #include "fsfw/housekeeping/PeriodicHousekeepingHelper.h"
@ -80,7 +81,9 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
   */
  LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
                       bool appendValidityBuffer = true);
-  virtual ~LocalDataPoolManager();
+  ~LocalDataPoolManager() override;
+
+  void setHkDestinationId(MessageQueueId_t hkDestId);

  /**
   * Assigns the queue to use. Make sure to call this in the #initialize
@ -112,31 +115,6 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
   */
  virtual ReturnValue_t performHkOperation();

-  /**
-   * @brief   Subscribe for the generation of periodic packets.
-   * @details
-   * This subscription mechanism will generally be used by the data creator
-   * to generate housekeeping packets which are downlinked directly.
-   * @return
-   */
-  ReturnValue_t subscribeForPeriodicPacket(
-      sid_t sid, bool enableReporting, float collectionInterval, bool isDiagnostics,
-      object_id_t packetDestination = defaultHkDestination) override;
-
-  /**
-   * @brief   Subscribe for the  generation of packets if the dataset
-   *          is marked as changed.
-   * @details
-   * This subscription mechanism will generally be used by the data creator.
-   * @param sid
-   * @param isDiagnostics
-   * @param packetDestination
-   * @return
-   */
-  ReturnValue_t subscribeForUpdatePacket(
-      sid_t sid, bool reportingEnabled, bool isDiagnostics,
-      object_id_t packetDestination = defaultHkDestination) override;
-
  /**
   * @brief   Subscribe for a notification message which will be sent
   *          if a dataset has changed.
@ -151,7 +129,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
   * Otherwise, only an notification message is sent.
   * @return
   */
-  ReturnValue_t subscribeForSetUpdateMessage(const uint32_t setId, object_id_t destinationObject,
+  ReturnValue_t subscribeForSetUpdateMessage(uint32_t setId, object_id_t destinationObject,
                                             MessageQueueId_t targetQueueId,
                                             bool generateSnapshot) override;

@ -169,7 +147,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
   * Otherwise, only an notification message is sent.
   * @return
   */
-  ReturnValue_t subscribeForVariableUpdateMessage(const lp_id_t localPoolId,
+  ReturnValue_t subscribeForVariableUpdateMessage(lp_id_t localPoolId,
                                                  object_id_t destinationObject,
                                                  MessageQueueId_t targetQueueId,
                                                  bool generateSnapshot) override;
@ -252,7 +230,7 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
   */
  void clearReceiversList();

-  object_id_t getCreatorObjectId() const;
+  [[nodiscard]] object_id_t getCreatorObjectId() const;

  /**
   * Get the pointer to the mutex. Can be used to lock the data pool
@ -262,7 +240,14 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces
   */
  MutexIF* getMutexHandle();

-  virtual LocalDataPoolManager* getPoolManagerHandle() override;
+  LocalDataPoolManager* getPoolManagerHandle() override;
+  ReturnValue_t subscribeForRegularPeriodicPacket(subdp::RegularHkPeriodicParams params) override;
+  ReturnValue_t subscribeForDiagPeriodicPacket(subdp::DiagnosticsHkPeriodicParams params) override;
+  ReturnValue_t subscribeForPeriodicPacket(subdp::ParamsBase& params);
+
+  ReturnValue_t subscribeForRegularUpdatePacket(subdp::RegularHkUpdateParams params) override;
+  ReturnValue_t subscribeForDiagUpdatePacket(subdp::DiagnosticsHkUpdateParams params) override;
+  ReturnValue_t subscribeForUpdatePacket(subdp::ParamsBase& params);

 protected:
  /** Core data structure for the actual pool data */
@ -312,8 +297,8 @@ class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public Acces

  using HkUpdateResetList = std::vector<struct HkUpdateResetHelper>;
  /** This list is used to manage creating multiple update packets and only resetting
-  the update flag if all of them were created. Will only be created when needed. */
-  HkUpdateResetList* hkUpdateResetList = nullptr;
+  the update flag if all of them were created. */
+  HkUpdateResetList hkUpdateResetList = HkUpdateResetList();

  /** This is the map holding the actual data. Should only be initialized
   * once ! */
--- a/src/fsfw/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ b/src/fsfw/datapoollocal/ProvidesDataPoolSubscriptionIF.h
@ -1,24 +1,90 @@
 #ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
 #define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_

-#include "../ipc/messageQueueDefinitions.h"
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/housekeeping/AcceptsHkPacketsIF.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/ipc/messageQueueDefinitions.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "localPoolDefinitions.h"

+namespace subdp {
+
+struct ParamsBase {
+  ParamsBase(sid_t sid, bool enableReporting, float collectionInterval, bool diagnostics)
+      : sid(sid),
+        enableReporting(enableReporting),
+        collectionInterval(collectionInterval),
+        diagnostics(diagnostics) {}
+
+  [[nodiscard]] bool isDiagnostics() const { return diagnostics; }
+
+  sid_t sid;
+  bool enableReporting;
+  float collectionInterval;
+  MessageQueueId_t receiver = MessageQueueIF::NO_QUEUE;
+
+ protected:
+  bool diagnostics;
+};
+
+struct RegularHkPeriodicParams : public ParamsBase {
+  RegularHkPeriodicParams(sid_t sid, bool enableReporting, float collectionInterval)
+      : ParamsBase(sid, enableReporting, collectionInterval, false) {}
+};
+
+struct DiagnosticsHkPeriodicParams : public ParamsBase {
+  DiagnosticsHkPeriodicParams(sid_t sid, bool enableReporting, float collectionInterval)
+      : ParamsBase(sid, enableReporting, collectionInterval, true) {}
+};
+
+struct RegularHkUpdateParams : public ParamsBase {
+  RegularHkUpdateParams(sid_t sid, bool enableReporting)
+      : ParamsBase(sid, enableReporting, 0.0, false) {}
+};
+
+struct DiagnosticsHkUpdateParams : public ParamsBase {
+  DiagnosticsHkUpdateParams(sid_t sid, bool enableReporting)
+      : ParamsBase(sid, enableReporting, 0.0, true) {}
+};
+}  // namespace subdp
+
 class ProvidesDataPoolSubscriptionIF {
 public:
-  virtual ~ProvidesDataPoolSubscriptionIF(){};
-
+  virtual ~ProvidesDataPoolSubscriptionIF() = default;
  /**
-   * @brief   Subscribe for the generation of periodic packets.
+   * @brief   Subscribe for the generation of periodic packets. Used for regular HK packets
   * @details
   * This subscription mechanism will generally be used by the data creator
   * to generate housekeeping packets which are downlinked directly.
   * @return
   */
-  virtual ReturnValue_t subscribeForPeriodicPacket(sid_t sid, bool enableReporting,
-                                                   float collectionInterval, bool isDiagnostics,
-                                                   object_id_t packetDestination) = 0;
+  virtual ReturnValue_t subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams params) = 0;
+  /**
+   * @brief   Subscribe for the generation of periodic packets. Used for diagnostic packets
+   * @details
+   * This subscription mechanism will generally be used by the data creator
+   * to generate housekeeping packets which are downlinked directly.
+   * @return
+   */
+  virtual ReturnValue_t subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams params) = 0;
+
+  [[deprecated(
+      "Please use the new API which takes all arguments as one wrapper "
+      "struct")]] virtual ReturnValue_t
+  subscribeForPeriodicPacket(sid_t sid, bool enableReporting, float collectionInterval,
+                             bool isDiagnostics,
+                             object_id_t packetDestination = objects::NO_OBJECT) {
+    if (isDiagnostics) {
+      subdp::DiagnosticsHkPeriodicParams params(sid, enableReporting, collectionInterval);
+      return subscribeForDiagPeriodicPacket(params);
+    } else {
+      subdp::RegularHkPeriodicParams params(sid, enableReporting, collectionInterval);
+      return subscribeForRegularPeriodicPacket(params);
+    }
+  }
+
  /**
   * @brief   Subscribe for the  generation of packets if the dataset
   *          is marked as changed.
@ -29,9 +95,28 @@ class ProvidesDataPoolSubscriptionIF {
   * @param packetDestination
   * @return
   */
-  virtual ReturnValue_t subscribeForUpdatePacket(sid_t sid, bool reportingEnabled,
-                                                 bool isDiagnostics,
-                                                 object_id_t packetDestination) = 0;
+  virtual ReturnValue_t subscribeForRegularUpdatePacket(subdp::RegularHkUpdateParams params) = 0;
+  virtual ReturnValue_t subscribeForDiagUpdatePacket(subdp::DiagnosticsHkUpdateParams params) = 0;
+
+  //  virtual ReturnValue_t
+  //  subscribeForUpdatePacket(sid_t sid, bool reportingEnabled, bool isDiagnostics) {
+  //    return subscribeForUpdatePacket(sid, reportingEnabled, isDiagnostics, objects::NO_OBJECT);
+  //  }
+
+  [[deprecated(
+      "Please use the new API which takes all arguments as one wrapper "
+      "struct")]] virtual ReturnValue_t
+  subscribeForUpdatePacket(sid_t sid, bool reportingEnabled, bool isDiagnostics,
+                           object_id_t packetDestination = objects::NO_OBJECT) {
+    if (isDiagnostics) {
+      subdp::DiagnosticsHkUpdateParams params(sid, reportingEnabled);
+      return subscribeForDiagUpdatePacket(params);
+    } else {
+      subdp::RegularHkUpdateParams params(sid, reportingEnabled);
+      return subscribeForRegularUpdatePacket(params);
+    }
+  }
+
  /**
   * @brief   Subscribe for a notification message which will be sent
   *          if a dataset has changed.
@ -46,8 +131,7 @@ class ProvidesDataPoolSubscriptionIF {
   *                              Otherwise, only an notification message is sent.
   * @return
   */
-  virtual ReturnValue_t subscribeForSetUpdateMessage(const uint32_t setId,
-                                                     object_id_t destinationObject,
+  virtual ReturnValue_t subscribeForSetUpdateMessage(uint32_t setId, object_id_t destinationObject,
                                                     MessageQueueId_t targetQueueId,
                                                     bool generateSnapshot) = 0;
  /**
@ -64,7 +148,7 @@ class ProvidesDataPoolSubscriptionIF {
   *                              only an notification message is sent.
   * @return
   */
-  virtual ReturnValue_t subscribeForVariableUpdateMessage(const lp_id_t localPoolId,
+  virtual ReturnValue_t subscribeForVariableUpdateMessage(lp_id_t localPoolId,
                                                          object_id_t destinationObject,
                                                          MessageQueueId_t targetQueueId,
                                                          bool generateSnapshot) = 0;
--- a/src/fsfw/health/HealthTable.h
+++ b/src/fsfw/health/HealthTable.h
@ -9,8 +9,8 @@

 class HealthTable : public HealthTableIF, public SystemObject {
 public:
-  HealthTable(object_id_t objectid);
-  virtual ~HealthTable();
+  explicit HealthTable(object_id_t objectid);
+  ~HealthTable() override;

  void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);

--- a/src/fsfw/housekeeping/AcceptsHkPacketsIF.h
+++ b/src/fsfw/housekeeping/AcceptsHkPacketsIF.h
@ -1,12 +1,12 @@
 #ifndef FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_
 #define FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_

-#include "../ipc/MessageQueueMessageIF.h"
+#include "fsfw/ipc/MessageQueueMessageIF.h"

 class AcceptsHkPacketsIF {
 public:
-  virtual ~AcceptsHkPacketsIF(){};
-  virtual MessageQueueId_t getHkQueue() const = 0;
+  virtual ~AcceptsHkPacketsIF() = default;
+  [[nodiscard]] virtual MessageQueueId_t getHkQueue() const = 0;
 };

 #endif /* FRAMEWORK_HOUSEKEEPING_ACCEPTSHKPACKETSIF_H_ */
--- a/src/fsfw/internalerror/InternalErrorReporter.cpp
+++ b/src/fsfw/internalerror/InternalErrorReporter.cpp
@ -127,11 +127,12 @@ MessageQueueId_t InternalErrorReporter::getCommandQueue() const {

 ReturnValue_t InternalErrorReporter::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                             LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(errorPoolIds::TM_HITS, new PoolEntry<uint32_t>());
-  localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS, new PoolEntry<uint32_t>());
-  localDataPoolMap.emplace(errorPoolIds::STORE_HITS, new PoolEntry<uint32_t>());
-  poolManager.subscribeForPeriodicPacket(internalErrorSid, false, getPeriodicOperationFrequency(),
-                                         true);
+  localDataPoolMap.emplace(errorPoolIds::TM_HITS, &tmHitsEntry);
+  localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS, &queueHitsEntry);
+  localDataPoolMap.emplace(errorPoolIds::STORE_HITS, &storeHitsEntry);
+  poolManager.subscribeForDiagPeriodicPacket(subdp::DiagnosticsHkPeriodicParams(
+      internalErrorSid, false,
+      static_cast<float>(getPeriodicOperationFrequency()) / static_cast<float>(1000.0)));
  internalErrorDataset.setValidity(true, true);
  return HasReturnvaluesIF::RETURN_OK;
 }
--- a/src/fsfw/internalerror/InternalErrorReporter.h
+++ b/src/fsfw/internalerror/InternalErrorReporter.h
@ -72,6 +72,9 @@ class InternalErrorReporter : public SystemObject,
  uint32_t queueHits = 0;
  uint32_t tmHits = 0;
  uint32_t storeHits = 0;
+  PoolEntry<uint32_t> tmHitsEntry = PoolEntry<uint32_t>();
+  PoolEntry<uint32_t> storeHitsEntry = PoolEntry<uint32_t>();
+  PoolEntry<uint32_t> queueHitsEntry = PoolEntry<uint32_t>();

  uint32_t getAndResetQueueHits();
  void incrementQueueHits();
--- a/src/fsfw/internalerror/InternalErrorReporterIF.h
+++ b/src/fsfw/internalerror/InternalErrorReporterIF.h
@ -12,7 +12,7 @@
 */
 class InternalErrorReporterIF {
 public:
-  virtual ~InternalErrorReporterIF() {}
+  virtual ~InternalErrorReporterIF() = default;
  /**
   * @brief Function to be called if a message queue could not be sent.
   * @details OSAL Implementations should call this function to indicate that
--- a/src/fsfw/ipc/MessageQueueBase.cpp
+++ b/src/fsfw/ipc/MessageQueueBase.cpp
@ -8,7 +8,7 @@ MessageQueueBase::MessageQueueBase(MessageQueueId_t id, MessageQueueId_t default
  }
 }

-MessageQueueBase::~MessageQueueBase() {}
+MessageQueueBase::~MessageQueueBase() = default;

 ReturnValue_t MessageQueueBase::sendToDefault(MessageQueueMessageIF* message) {
  return sendToDefaultFrom(message, this->getId(), false);
--- a/src/fsfw/ipc/MessageQueueBase.h
+++ b/src/fsfw/ipc/MessageQueueBase.h
@ -7,28 +7,28 @@
 class MessageQueueBase : public MessageQueueIF {
 public:
  MessageQueueBase(MessageQueueId_t id, MessageQueueId_t defaultDest, MqArgs* mqArgs);
-  virtual ~MessageQueueBase();
+  ~MessageQueueBase() override;

  // Default implementations for MessageQueueIF where possible
-  virtual MessageQueueId_t getLastPartner() const override;
-  virtual MessageQueueId_t getId() const override;
-  virtual MqArgs& getMqArgs() override;
-  virtual void setDefaultDestination(MessageQueueId_t defaultDestination) override;
-  virtual MessageQueueId_t getDefaultDestination() const override;
-  virtual bool isDefaultDestinationSet() const override;
-  virtual ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                    bool ignoreFault) override;
-  virtual ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
-  virtual ReturnValue_t reply(MessageQueueMessageIF* message) override;
-  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
-                                       MessageQueueId_t* receivedFrom) override;
-  virtual ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
-                                          bool ignoreFault = false) override;
+  [[nodiscard]] MessageQueueId_t getLastPartner() const override;
+  [[nodiscard]] MessageQueueId_t getId() const override;
+  MqArgs& getMqArgs() override;
+  void setDefaultDestination(MessageQueueId_t defaultDestination) override;
+  [[nodiscard]] MessageQueueId_t getDefaultDestination() const override;
+  [[nodiscard]] bool isDefaultDestinationSet() const override;
+  ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                            bool ignoreFault) override;
+  ReturnValue_t sendToDefault(MessageQueueMessageIF* message) override;
+  ReturnValue_t reply(MessageQueueMessageIF* message) override;
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message,
+                               MessageQueueId_t* receivedFrom) override;
+  ReturnValue_t sendToDefaultFrom(MessageQueueMessageIF* message, MessageQueueId_t sentFrom,
+                                  bool ignoreFault = false) override;

  // OSAL specific, forward the abstract function
-  virtual ReturnValue_t receiveMessage(MessageQueueMessageIF* message) = 0;
-  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
-                                        MessageQueueId_t sentFrom, bool ignoreFault = false) = 0;
+  ReturnValue_t receiveMessage(MessageQueueMessageIF* message) override = 0;
+  ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
+                                MessageQueueId_t sentFrom, bool ignoreFault = false) override = 0;

 protected:
  MessageQueueId_t id = MessageQueueIF::NO_QUEUE;
--- a/src/fsfw/ipc/MessageQueueIF.h
+++ b/src/fsfw/ipc/MessageQueueIF.h
@ -30,7 +30,7 @@ class MessageQueueIF {
  //! [EXPORT] : [COMMENT] Returned if the target destination is invalid.
  static constexpr ReturnValue_t DESTINATION_INVALID = MAKE_RETURN_CODE(4);

-  virtual ~MessageQueueIF() {}
+  virtual ~MessageQueueIF() = default;
  /**
   * @brief	This operation sends a message to the last communication partner.
   * @details
@ -82,11 +82,11 @@ class MessageQueueIF {
  /**
   * @brief	This method returns the message queue ID of the last communication partner.
   */
-  virtual MessageQueueId_t getLastPartner() const = 0;
+  [[nodiscard]] virtual MessageQueueId_t getLastPartner() const = 0;
  /**
   * @brief	This method returns the message queue ID  of this class's message queue.
   */
-  virtual MessageQueueId_t getId() const = 0;
+  [[nodiscard]] virtual MessageQueueId_t getId() const = 0;

  /**
   * @brief	With the sendMessage call, a queue message is sent to a receiving queue.
@ -159,9 +159,9 @@ class MessageQueueIF {
  /**
   * @brief	This method is a simple getter for the default destination.
   */
-  virtual MessageQueueId_t getDefaultDestination() const = 0;
+  [[nodiscard]] virtual MessageQueueId_t getDefaultDestination() const = 0;

-  virtual bool isDefaultDestinationSet() const = 0;
+  [[nodiscard]] virtual bool isDefaultDestinationSet() const = 0;

  virtual MqArgs& getMqArgs() = 0;
 };
--- a/src/fsfw/ipc/MessageQueueMessage.cpp
+++ b/src/fsfw/ipc/MessageQueueMessage.cpp
@ -10,10 +10,10 @@ MessageQueueMessage::MessageQueueMessage() : messageSize(getMinimumMessageSize()
 }

 MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size)
-    : messageSize(this->HEADER_SIZE + size) {
-  if (size <= this->MAX_DATA_SIZE) {
-    memcpy(this->getData(), data, size);
-    this->messageSize = this->HEADER_SIZE + size;
+    : messageSize(MessageQueueMessage::HEADER_SIZE + size) {
+  if (size <= MessageQueueMessage::MAX_DATA_SIZE) {
+    std::memcpy(internalBuffer + MessageQueueMessage::HEADER_SIZE, data, size);
+    this->messageSize = MessageQueueMessage::HEADER_SIZE + size;
  } else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "MessageQueueMessage: Passed size larger than maximum"
@ -21,21 +21,23 @@ MessageQueueMessage::MessageQueueMessage(uint8_t* data, size_t size)
                 << std::endl;
 #endif
    memset(this->internalBuffer, 0, sizeof(this->internalBuffer));
-    this->messageSize = this->HEADER_SIZE;
+    this->messageSize = MessageQueueMessage::HEADER_SIZE;
  }
 }

-MessageQueueMessage::~MessageQueueMessage() {}
+MessageQueueMessage::~MessageQueueMessage() = default;

 const uint8_t* MessageQueueMessage::getBuffer() const { return this->internalBuffer; }

 uint8_t* MessageQueueMessage::getBuffer() { return this->internalBuffer; }

 const uint8_t* MessageQueueMessage::getData() const {
-  return this->internalBuffer + this->HEADER_SIZE;
+  return this->internalBuffer + MessageQueueMessage::HEADER_SIZE;
 }

-uint8_t* MessageQueueMessage::getData() { return this->internalBuffer + this->HEADER_SIZE; }
+uint8_t* MessageQueueMessage::getData() {
+  return this->internalBuffer + MessageQueueMessage::HEADER_SIZE;
+}

 MessageQueueId_t MessageQueueMessage::getSender() const {
  MessageQueueId_t temp_id;
@ -58,14 +60,22 @@ void MessageQueueMessage::print(bool printWholeMessage) {
  }
 }

-void MessageQueueMessage::clear() { memset(this->getBuffer(), 0, this->MAX_MESSAGE_SIZE); }
+void MessageQueueMessage::clear() {
+  memset(this->getBuffer(), 0, MessageQueueMessage::MAX_MESSAGE_SIZE);
+}

 size_t MessageQueueMessage::getMessageSize() const { return this->messageSize; }

-void MessageQueueMessage::setMessageSize(size_t messageSize) { this->messageSize = messageSize; }
+void MessageQueueMessage::setMessageSize(size_t messageSize_) { this->messageSize = messageSize_; }

-size_t MessageQueueMessage::getMinimumMessageSize() const { return this->MIN_MESSAGE_SIZE; }
+size_t MessageQueueMessage::getMinimumMessageSize() const {
+  return MessageQueueMessage::MIN_MESSAGE_SIZE;
+}

-size_t MessageQueueMessage::getMaximumMessageSize() const { return this->MAX_MESSAGE_SIZE; }
+size_t MessageQueueMessage::getMaximumMessageSize() const {
+  return MessageQueueMessage::MAX_MESSAGE_SIZE;
+}

-size_t MessageQueueMessage::getMaximumDataSize() const { return this->MAX_DATA_SIZE; }
+size_t MessageQueueMessage::getMaximumDataSize() const {
+  return MessageQueueMessage::MAX_DATA_SIZE;
+}
--- a/src/fsfw/ipc/MessageQueueMessage.h
+++ b/src/fsfw/ipc/MessageQueueMessage.h
@ -25,6 +25,30 @@
 */
 class MessageQueueMessage : public MessageQueueMessageIF {
 public:
+  /**
+   * @brief	This constant defines the maximum size of the data content,
+   * 			excluding the header.
+   * @details
+   * It may be changed if necessary, but in general should be kept
+   * as small as possible.
+   */
+  static const size_t MAX_DATA_SIZE = 24;
+  /**
+   * @brief	This constant defines the maximum total size in bytes
+   * 			of a sent message.
+   * @details
+   * It is the sum of the maximum data and the header size. Be aware that
+   * this constant is used to define the buffer sizes for every message
+   * queue in the system. So, a change here may have significant impact on
+   * the required resources.
+   */
+  static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
+  /**
+   * @brief Defines the minimum size of a message where only the
+   * 		  header is included
+   */
+  static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
+
  /**
   * @brief	The class is initialized empty with this constructor.
   * @details
@ -50,59 +74,12 @@ class MessageQueueMessage : public MessageQueueMessageIF {
   * @brief	As no memory is allocated in this class,
   * 		    the destructor is empty.
   */
-  virtual ~MessageQueueMessage();
+  ~MessageQueueMessage() override;

-  /**
-   * @brief	The size information of each message is stored in
-   *  			this attribute.
-   * @details
-   * It is public to simplify usage and to allow for passing the size
-   * address as a pointer. Care must be taken when inheriting from this class,
-   * as every child class is responsible for managing the size information by
-   * itself. When using the class to receive a message, the size information
-   * is updated automatically.
-   *
-   * Please note that the minimum size is limited by the size of the header
-   * while the maximum size is limited by the maximum allowed message size.
-   */
-  size_t messageSize;
-  /**
-   * @brief	This constant defines the maximum size of the data content,
-   * 			excluding the header.
-   * @details
-   * It may be changed if necessary, but in general should be kept
-   * as small as possible.
-   */
-  static const size_t MAX_DATA_SIZE = 24;
-
-  /**
-   * @brief	This constant defines the maximum total size in bytes
-   * 			of a sent message.
-   * @details
-   * It is the sum of the maximum data and the header size. Be aware that
-   * this constant is used to define the buffer sizes for every message
-   * queue in the system. So, a change here may have significant impact on
-   * the required resources.
-   */
-  static constexpr size_t MAX_MESSAGE_SIZE = MAX_DATA_SIZE + HEADER_SIZE;
-  /**
-   * @brief Defines the minimum size of a message where only the
-   * 		  header is included
-   */
-  static constexpr size_t MIN_MESSAGE_SIZE = HEADER_SIZE;
-
- private:
-  /**
-   * @brief	This is the internal buffer that contains the
-   * 			actual message data.
-   */
-  uint8_t internalBuffer[MAX_MESSAGE_SIZE];
-
- public:
  /**
   * @brief	This method is used to get the complete data of the message.
   */
-  const uint8_t* getBuffer() const override;
+  [[nodiscard]] const uint8_t* getBuffer() const override;
  /**
   * @brief	This method is used to get the complete data of the message.
   */
@ -112,7 +89,7 @@ class MessageQueueMessage : public MessageQueueMessageIF {
   * @details
   * It shall be used by child classes to add data at the right position.
   */
-  const uint8_t* getData() const override;
+  [[nodiscard]] const uint8_t* getData() const override;
  /**
   * @brief	This method is used to fetch the data content of the message.
   * @details
@ -123,7 +100,7 @@ class MessageQueueMessage : public MessageQueueMessageIF {
   * @brief	This method is used to extract the sender's message
   * 			queue id information from a received message.
   */
-  MessageQueueId_t getSender() const override;
+  [[nodiscard]] MessageQueueId_t getSender() const override;
  /**
   * @brief	With this method, the whole content
   * 			and the message size is set to zero.
@ -138,16 +115,40 @@ class MessageQueueMessage : public MessageQueueMessageIF {
   */
  void setSender(MessageQueueId_t setId) override;

-  virtual size_t getMessageSize() const override;
-  virtual void setMessageSize(size_t messageSize) override;
-  virtual size_t getMinimumMessageSize() const override;
-  virtual size_t getMaximumMessageSize() const override;
-  virtual size_t getMaximumDataSize() const override;
+  [[nodiscard]] size_t getMessageSize() const override;
+  void setMessageSize(size_t messageSize) override;
+  [[nodiscard]] size_t getMinimumMessageSize() const override;
+  [[nodiscard]] size_t getMaximumMessageSize() const override;
+  [[nodiscard]] size_t getMaximumDataSize() const override;

  /**
   * @brief	This is a debug method that prints the content.
   */
  void print(bool printWholeMessage);
+
+  /**
+   * TODO: This really should not be public. If it should be possible to pass size address as a
+   *       pointer, add a getter function returning a const reference to the size
+   * @brief	The size information of each message is stored in
+   *  			this attribute.
+   * @details
+   * It is public to simplify usage and to allow for passing the size
+   * address as a pointer. Care must be taken when inheriting from this class,
+   * as every child class is responsible for managing the size information by
+   * itself. When using the class to receive a message, the size information
+   * is updated automatically.
+   *
+   * Please note that the minimum size is limited by the size of the header
+   * while the maximum size is limited by the maximum allowed message size.
+   */
+  size_t messageSize;
+
+ private:
+  /**
+   * @brief	This is the internal buffer that contains the
+   * 			actual message data.
+   */
+  uint8_t internalBuffer[MAX_MESSAGE_SIZE] = {};
 };

 #endif /* FSFW_IPC_MESSAGEQUEUEMESSAGE_H_ */
--- a/src/fsfw/ipc/MessageQueueMessageIF.h
+++ b/src/fsfw/ipc/MessageQueueMessageIF.h
@ -14,7 +14,7 @@ class MessageQueueMessageIF {
   */
  static const size_t HEADER_SIZE = sizeof(MessageQueueId_t);

-  virtual ~MessageQueueMessageIF(){};
+  virtual ~MessageQueueMessageIF() = default;

  /**
   * @brief	With this method, the whole content and the message
@ -29,7 +29,7 @@ class MessageQueueMessageIF {
   * @brief	Get read-only pointer to the complete data of the message.
   * @return
   */
-  virtual const uint8_t* getBuffer() const = 0;
+  [[nodiscard]] virtual const uint8_t* getBuffer() const = 0;

  /**
   * @brief	This method is used to get the complete data of the message.
@ -48,14 +48,14 @@ class MessageQueueMessageIF {
   * @brief	This method is used to extract the sender's message queue id
   * 			information from a received message.
   */
-  virtual MessageQueueId_t getSender() const = 0;
+  [[nodiscard]] virtual MessageQueueId_t getSender() const = 0;

  /**
   * @brief	This method is used to fetch the data content of the message.
   * @details
   * It shall be used by child classes to add data at the right position.
   */
-  virtual const uint8_t* getData() const = 0;
+  [[nodiscard]] virtual const uint8_t* getData() const = 0;
  /**
   * @brief	This method is used to fetch the data content of the message.
   * @details
@ -67,12 +67,28 @@ class MessageQueueMessageIF {
   * Get constant message size of current message implementation.
   * @return
   */
-  virtual size_t getMessageSize() const = 0;
+  [[nodiscard]] virtual size_t getMessageSize() const = 0;

+  /**
+   * Sets the current message size of a given message
+   * @param messageSize
+   */
  virtual void setMessageSize(size_t messageSize) = 0;
-  virtual size_t getMinimumMessageSize() const = 0;
-  virtual size_t getMaximumMessageSize() const = 0;
-  virtual size_t getMaximumDataSize() const = 0;
+  /**
+   * Returns the smallest possible message size, including any headers
+   * @return
+   */
+  [[nodiscard]] virtual size_t getMinimumMessageSize() const = 0;
+  /**
+   * Returns the largest possible message size, including any headers
+   * @return
+   */
+  [[nodiscard]] virtual size_t getMaximumMessageSize() const = 0;
+  /**
+   * Returns the largest possible data size without any headers
+   * @return
+   */
+  [[nodiscard]] virtual size_t getMaximumDataSize() const = 0;
 };

 #endif /* FRAMEWORK_IPC_MESSAGEQUEUEMESSAGEIF_H_ */
--- a/src/fsfw/ipc/MessageQueueSenderIF.h
+++ b/src/fsfw/ipc/MessageQueueSenderIF.h
@ -1,14 +1,14 @@
 #ifndef FSFW_IPC_MESSAGEQUEUESENDERIF_H_
 #define FSFW_IPC_MESSAGEQUEUESENDERIF_H_

-#include "../objectmanager/ObjectManagerIF.h"
 #include "MessageQueueIF.h"
 #include "MessageQueueMessageIF.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"

 class MessageQueueSenderIF {
 public:
-  virtual ~MessageQueueSenderIF() {}
-
+  virtual ~MessageQueueSenderIF() = default;
+  MessageQueueSenderIF() = delete;
  /**
   * Allows sending messages without actually "owning" a message queue.
   * Not sure whether this is actually a good idea.
@ -16,9 +16,6 @@ class MessageQueueSenderIF {
  static ReturnValue_t sendMessage(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
                                   MessageQueueId_t sentFrom = MessageQueueIF::NO_QUEUE,
                                   bool ignoreFault = false);
-
- private:
-  MessageQueueSenderIF() {}
 };

 #endif /* FSFW_IPC_MESSAGEQUEUESENDERIF_H_ */
--- a/src/fsfw/monitoring/MonitoringMessageContent.h
+++ b/src/fsfw/monitoring/MonitoringMessageContent.h
@ -34,7 +34,7 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
  SerializeElement<T> limitValue;
  SerializeElement<ReturnValue_t> oldState;
  SerializeElement<ReturnValue_t> newState;
-  uint8_t rawTimestamp[TimeStamperIF::MISSION_TIMESTAMP_SIZE] = {};
+  uint8_t rawTimestamp[TimeStamperIF::MAXIMUM_TIMESTAMP_LEN] = {};
  SerializeElement<SerialBufferAdapter<uint8_t>> timestampSerializer;
  TimeStamperIF* timeStamper;
  MonitoringReportContent()
@ -47,7 +47,7 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
        oldState(0),
        newState(0),
        timestampSerializer(rawTimestamp, sizeof(rawTimestamp)),
-        timeStamper(NULL) {
+        timeStamper(nullptr) {
    setAllNext();
  }
  MonitoringReportContent(gp_id_t globalPoolId, T value, T limitValue, ReturnValue_t oldState,
@ -61,7 +61,7 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
        oldState(oldState),
        newState(newState),
        timestampSerializer(rawTimestamp, sizeof(rawTimestamp)),
-        timeStamper(NULL) {
+        timeStamper(nullptr) {
    setAllNext();
    if (checkAndSetStamper()) {
      timeStamper->addTimeStamp(rawTimestamp, sizeof(rawTimestamp));
--- a/src/fsfw/objectmanager/ObjectManager.cpp
+++ b/src/fsfw/objectmanager/ObjectManager.cpp
@ -21,7 +21,7 @@ void ObjectManager::setObjectFactoryFunction(produce_function_t objFactoryFunc,
  this->factoryArgs = factoryArgs;
 }

-ObjectManager::ObjectManager() {}
+ObjectManager::ObjectManager() = default;

 ObjectManager::~ObjectManager() {
  for (auto const& iter : objectList) {
@ -36,7 +36,7 @@ ReturnValue_t ObjectManager::insert(object_id_t id, SystemObjectIF* object) {
    // sif::debug << "ObjectManager::insert: Object " << std::hex
    //            << (int)id << std::dec << " inserted." << std::endl;
 #endif
-    return this->RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
  } else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "ObjectManager::insert: Object ID " << std::hex << static_cast<uint32_t>(id)
@ -53,7 +53,7 @@ ReturnValue_t ObjectManager::insert(object_id_t id, SystemObjectIF* object) {
 }

 ReturnValue_t ObjectManager::remove(object_id_t id) {
-  if (this->getSystemObject(id) != NULL) {
+  if (this->getSystemObject(id) != nullptr) {
    this->objectList.erase(id);
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    // sif::debug << "ObjectManager::removeObject: Object " << std::hex
--- a/src/fsfw/objectmanager/ObjectManager.h
+++ b/src/fsfw/objectmanager/ObjectManager.h
@ -38,7 +38,7 @@ class ObjectManager : public ObjectManagerIF {
  /**
   *  @brief  In the class's destructor, all objects in the list are deleted.
   */
-  virtual ~ObjectManager();
+  ~ObjectManager() override;
  ReturnValue_t insert(object_id_t id, SystemObjectIF* object) override;
  ReturnValue_t remove(object_id_t id) override;
  void initialize() override;
--- a/src/fsfw/objectmanager/frameworkObjects.h
+++ b/src/fsfw/objectmanager/frameworkObjects.h
@ -33,6 +33,7 @@ enum framework_objects : object_id_t {
  TC_STORE = 0x534f0100,
  TM_STORE = 0x534f0200,
  TIME_STAMPER = 0x53500010,
+  TC_VERIFICATOR = 0x53500020,

  FSFW_OBJECTS_END = 0x53ffffff,
  NO_OBJECT = 0xFFFFFFFF
--- a/src/fsfw/osal/common/TcpTmTcServer.h
+++ b/src/fsfw/osal/common/TcpTmTcServer.h
@ -108,7 +108,7 @@ class TcpTmTcServer : public SystemObject, public TcpIpBase, public ExecutableOb
  StorageManagerIF* tmStore = nullptr;

 private:
-  static constexpr ReturnValue_t CONN_BROKEN = HasReturnvaluesIF::makeReturnCode(1, 0);
+  static constexpr ReturnValue_t CONN_BROKEN = result::makeCode(1, 0);
  //! TMTC bridge is cached.
  object_id_t tmtcBridgeId = objects::NO_OBJECT;
  TcpTmTcBridge* tmtcBridge = nullptr;
--- a/src/fsfw/osal/host/Clock.cpp
+++ b/src/fsfw/osal/host/Clock.cpp
@ -146,7 +146,7 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
 }

 ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
-  struct tm time_tm;
+  struct tm time_tm {};

  time_tm.tm_year = from->year - 1900;
  time_tm.tm_mon = from->month - 1;
--- a/src/fsfw/osal/host/MessageQueue.cpp
+++ b/src/fsfw/osal/host/MessageQueue.cpp
@ -65,11 +65,11 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
    // But I will still return a failure here.
    return HasReturnvaluesIF::RETURN_FAILED;
  }
-  MessageQueue* targetQueue =
+  auto* targetQueue =
      dynamic_cast<MessageQueue*>(QueueMapManager::instance()->getMessageQueue(sendTo));
  if (targetQueue == nullptr) {
    if (not ignoreFault) {
-      InternalErrorReporterIF* internalErrorReporter =
+      auto* internalErrorReporter =
          ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
      if (internalErrorReporter != nullptr) {
        internalErrorReporter->queueMessageNotSent();
@ -84,7 +84,7 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
           message->getMaximumMessageSize());
  } else {
    if (not ignoreFault) {
-      InternalErrorReporterIF* internalErrorReporter =
+      auto* internalErrorReporter =
          ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
      if (internalErrorReporter != nullptr) {
        internalErrorReporter->queueMessageNotSent();
--- a/src/fsfw/osal/host/MessageQueue.h
+++ b/src/fsfw/osal/host/MessageQueue.h
@ -68,7 +68,7 @@ class MessageQueue : public MessageQueueBase {
   * @details	This is accomplished by using the delete call provided
   * 			by the operating system.
   */
-  virtual ~MessageQueue();
+  ~MessageQueue() override;

  // Implement non-generic MessageQueueIF functions not handled by MessageQueueBase
  virtual ReturnValue_t sendMessageFrom(MessageQueueId_t sendTo, MessageQueueMessageIF* message,
@ -111,8 +111,6 @@ class MessageQueue : public MessageQueueBase {
  size_t messageDepth = 0;

  MutexIF* queueLock;
-
-  MessageQueueId_t defaultDestination = MessageQueueIF::NO_QUEUE;
 };

 #endif /* FRAMEWORK_OSAL_HOST_MESSAGEQUEUE_H_ */
--- a/src/fsfw/osal/host/QueueFactory.cpp
+++ b/src/fsfw/osal/host/QueueFactory.cpp
@ -13,7 +13,6 @@ ReturnValue_t MessageQueueSenderIF::sendMessage(MessageQueueId_t sendTo,
                                                MessageQueueMessageIF* message,
                                                MessageQueueId_t sentFrom, bool ignoreFault) {
  return MessageQueue::sendMessageFromMessageQueue(sendTo, message, sentFrom, ignoreFault);
-  return HasReturnvaluesIF::RETURN_OK;
 }

 QueueFactory* QueueFactory::instance() {
@ -23,9 +22,9 @@ QueueFactory* QueueFactory::instance() {
  return factoryInstance;
 }

-QueueFactory::QueueFactory() {}
+QueueFactory::QueueFactory() = default;

-QueueFactory::~QueueFactory() {}
+QueueFactory::~QueueFactory() = default;

 MessageQueueIF* QueueFactory::createMessageQueue(uint32_t messageDepth, size_t maxMessageSize,
                                                 MqArgs* args) {
--- a/src/fsfw/osal/host/QueueMapManager.cpp
+++ b/src/fsfw/osal/host/QueueMapManager.cpp
@ -54,7 +54,7 @@ MessageQueueIF* QueueMapManager::getMessageQueue(MessageQueueId_t messageQueueId
  } else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "QueueMapManager::getQueueHandle: The ID " << messageQueueId
-                 << " does not exists in the map!" << std::endl;
+                 << " does not exist in the map" << std::endl;
 #else
    sif::printWarning("QueueMapManager::getQueueHandle: The ID %d does not exist in the map!\n",
                      messageQueueId);
--- a/src/fsfw/osal/linux/Clock.cpp
+++ b/src/fsfw/osal/linux/Clock.cpp
@ -2,23 +2,22 @@

 #include <linux/sysinfo.h>
 #include <sys/sysinfo.h>
-#include <sys/time.h>
-#include <time.h>
 #include <unistd.h>

+#include <ctime>
 #include <fstream>

 #include "fsfw/ipc/MutexGuard.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"

-uint32_t Clock::getTicksPerSecond(void) {
+uint32_t Clock::getTicksPerSecond() {
  uint32_t ticks = sysconf(_SC_CLK_TCK);
  return ticks;
 }

 ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
-  timespec timeUnix;
-  timeval timeTimeval;
+  timespec timeUnix{};
+  timeval timeTimeval{};
  convertTimeOfDayToTimeval(time, &timeTimeval);
  timeUnix.tv_sec = timeTimeval.tv_sec;
  timeUnix.tv_nsec = (__syscall_slong_t)timeTimeval.tv_usec * 1000;
@ -32,7 +31,7 @@ ReturnValue_t Clock::setClock(const TimeOfDay_t* time) {
 }

 ReturnValue_t Clock::setClock(const timeval* time) {
-  timespec timeUnix;
+  timespec timeUnix{};
  timeUnix.tv_sec = time->tv_sec;
  timeUnix.tv_nsec = (__syscall_slong_t)time->tv_usec * 1000;
  int status = clock_settime(CLOCK_REALTIME, &timeUnix);
@ -44,7 +43,7 @@ ReturnValue_t Clock::setClock(const timeval* time) {
 }

 ReturnValue_t Clock::getClock_timeval(timeval* time) {
-  timespec timeUnix;
+  timespec timeUnix{};
  int status = clock_gettime(CLOCK_REALTIME, &timeUnix);
  if (status != 0) {
    return HasReturnvaluesIF::RETURN_FAILED;
@ -55,18 +54,18 @@ ReturnValue_t Clock::getClock_timeval(timeval* time) {
 }

 ReturnValue_t Clock::getClock_usecs(uint64_t* time) {
-  timeval timeVal;
+  timeval timeVal{};
  ReturnValue_t result = getClock_timeval(&timeVal);
  if (result != HasReturnvaluesIF::RETURN_OK) {
    return result;
  }
-  *time = (uint64_t)timeVal.tv_sec * 1e6 + timeVal.tv_usec;
+  *time = static_cast<uint64_t>(timeVal.tv_sec) * 1e6 + timeVal.tv_usec;

  return HasReturnvaluesIF::RETURN_OK;
 }

 timeval Clock::getUptime() {
-  timeval uptime;
+  timeval uptime{};
  auto result = getUptime(&uptime);
  if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@ -99,7 +98,7 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
 //}

 ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
-  timeval uptime;
+  timeval uptime{};
  ReturnValue_t result = getUptime(&uptime);
  if (result != HasReturnvaluesIF::RETURN_OK) {
    return result;
@ -109,7 +108,7 @@ ReturnValue_t Clock::getUptime(uint32_t* uptimeMs) {
 }

 ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
-  timespec timeUnix;
+  timespec timeUnix{};
  int status = clock_gettime(CLOCK_REALTIME, &timeUnix);
  if (status != 0) {
    // TODO errno
@ -122,7 +121,7 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
  MutexGuard helper(timeMutex);
  // gmtime writes its output in a global buffer which is not Thread Safe
  // Therefore we have to use a Mutex here
-  struct tm* timeInfo;
+  struct std::tm* timeInfo;
  timeInfo = gmtime(&timeUnix.tv_sec);
  time->year = timeInfo->tm_year + 1900;
  time->month = timeInfo->tm_mon + 1;
@ -136,7 +135,7 @@ ReturnValue_t Clock::getDateAndTime(TimeOfDay_t* time) {
 }

 ReturnValue_t Clock::convertTimeOfDayToTimeval(const TimeOfDay_t* from, timeval* to) {
-  tm fromTm;
+  std::tm fromTm{};
  // Note: Fails for years before AD
  fromTm.tm_year = from->year - 1900;
  fromTm.tm_mon = from->month - 1;
--- a/src/fsfw/parameters/ParameterMessage.cpp
+++ b/src/fsfw/parameters/ParameterMessage.cpp
@ -44,7 +44,7 @@ store_address_t ParameterMessage::getParameterLoadCommand(const CommandMessage*
  *pfc = packedParamSettings >> 16 & 0xff;
  *rows = packedParamSettings >> 8 & 0xff;
  *columns = packedParamSettings & 0xff;
-  return message->getParameter2();
+  return static_cast<store_address_t>(message->getParameter2());
 }

 void ParameterMessage::clear(CommandMessage* message) {
--- a/src/fsfw/pus/CService200ModeCommanding.cpp
+++ b/src/fsfw/pus/CService200ModeCommanding.cpp
@ -96,13 +96,13 @@ ReturnValue_t CService200ModeCommanding::handleReply(const CommandMessage *reply
 ReturnValue_t CService200ModeCommanding::prepareModeReply(const CommandMessage *reply,
                                                          object_id_t objectId) {
  ModePacket modeReplyPacket(objectId, ModeMessage::getMode(reply), ModeMessage::getSubmode(reply));
-  return sendTmPacket(Subservice::REPLY_MODE_REPLY, &modeReplyPacket);
+  return sendTmPacket(Subservice::REPLY_MODE_REPLY, modeReplyPacket);
 }

 ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(const CommandMessage *reply,
                                                               object_id_t objectId) {
  ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply), ModeMessage::getSubmode(reply));
-  ReturnValue_t result = sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
+  ReturnValue_t result = sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, wrongModeReply);
  if (result == RETURN_OK) {
    // We want to produce an error here in any case because the mode was not correct
    return RETURN_FAILED;
@ -113,7 +113,7 @@ ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(const CommandMess
 ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(const CommandMessage *reply,
                                                                   object_id_t objectId) {
  CantReachModePacket cantReachModePacket(objectId, ModeMessage::getCantReachModeReason(reply));
-  ReturnValue_t result = sendTmPacket(Subservice::REPLY_CANT_REACH_MODE, &cantReachModePacket);
+  ReturnValue_t result = sendTmPacket(Subservice::REPLY_CANT_REACH_MODE, cantReachModePacket);
  if (result == RETURN_OK) {
    // We want to produce an error here in any case because the mode was not reached
    return RETURN_FAILED;
--- a/src/fsfw/pus/CService201HealthCommanding.cpp
+++ b/src/fsfw/pus/CService201HealthCommanding.cpp
@ -102,5 +102,5 @@ ReturnValue_t CService201HealthCommanding::handleReply(const CommandMessage *rep
  auto health = static_cast<uint8_t>(HealthMessage::getHealth(reply));
  auto oldHealth = static_cast<uint8_t>(HealthMessage::getOldHealth(reply));
  HealthSetReply healthSetReply(health, oldHealth);
-  return sendTmPacket(Subservice::REPLY_HEALTH_SET, &healthSetReply);
+  return sendTmPacket(Subservice::REPLY_HEALTH_SET, healthSetReply);
 }
--- a/src/fsfw/pus/Service11TelecommandScheduling.h
+++ b/src/fsfw/pus/Service11TelecommandScheduling.h
@ -74,8 +74,7 @@ class Service11TelecommandScheduling final : public PusServiceBase {
    TO_TIMETAG = 3
  };

-  Service11TelecommandScheduling(object_id_t objectId, uint16_t apid, uint8_t serviceId,
-                                 AcceptsTelecommandsIF* tcRecipient,
+  Service11TelecommandScheduling(PsbParams params, AcceptsTelecommandsIF* tcRecipient,
                                 uint16_t releaseTimeMarginSeconds = DEFAULT_RELEASE_TIME_MARGIN,
                                 bool debugMode = false);

@ -159,7 +158,7 @@ class Service11TelecommandScheduling final : public PusServiceBase {
   * @param data The Application data of the TC (get via getApplicationData()).
   * @return requestId
   */
-  uint64_t getRequestIdFromDataTC(const uint8_t* data) const;
+  [[nodiscard]] uint64_t getRequestIdFromTc() const;

  /**
   * @brief Extracts the Request ID from the Application Data directly, assuming it is packed
--- a/src/fsfw/pus/Service11TelecommandScheduling.tpp
+++ b/src/fsfw/pus/Service11TelecommandScheduling.tpp
@ -11,9 +11,9 @@ static constexpr auto DEF_END = SerializeIF::Endianness::BIG;

 template <size_t MAX_NUM_TCS>
 inline Service11TelecommandScheduling<MAX_NUM_TCS>::Service11TelecommandScheduling(
-    object_id_t objectId, uint16_t apid, uint8_t serviceId, AcceptsTelecommandsIF *tcRecipient,
-    uint16_t releaseTimeMarginSeconds, bool debugMode)
-    : PusServiceBase(objectId, apid, serviceId),
+    PsbParams params, AcceptsTelecommandsIF *tcRecipient, uint16_t releaseTimeMarginSeconds,
+    bool debugMode)
+    : PusServiceBase(params),
      RELEASE_TIME_MARGIN_SECONDS(releaseTimeMarginSeconds),
      debugMode(debugMode),
      tcRecipient(tcRecipient) {}
@ -32,11 +32,8 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::handleRequest(
 #endif
  }
  // Get de-serialized Timestamp
-  const uint8_t *data = currentPacket.getApplicationData();
-  size_t size = currentPacket.getApplicationDataSize();
-  if (data == nullptr) {
-    return handleInvalidData("handleRequest");
-  }
+  const uint8_t *data = currentPacket.getUserData();
+  size_t size = currentPacket.getUserDataLen();
  switch (subservice) {
    case Subservice::ENABLE_SCHEDULING: {
      schedulingEnabled = true;
@ -82,7 +79,7 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::performService
      if (schedulingEnabled) {
        // release tc
        TmTcMessage releaseMsg(it->second.storeAddr);
-        auto sendRet = this->requestQueue->sendMessage(recipientMsgQueueId, &releaseMsg, false);
+        auto sendRet = psbParams.reqQueue->sendMessage(recipientMsgQueueId, &releaseMsg, false);

        if (sendRet != HasReturnvaluesIF::RETURN_OK) {
          return sendRet;
@ -175,7 +172,7 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doInsertActivi
  // store currentPacket and receive the store address
  store_address_t addr{};
  if (tcStore->addData(&addr, data, size) != RETURN_OK ||
-      addr.raw == storeId::INVALID_STORE_ADDRESS) {
+      addr.raw == store_address_t::INVALID_RAW) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "Service11TelecommandScheduling::doInsertActivity: Adding data to TC Store failed"
               << std::endl;
@ -190,8 +187,7 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doInsertActivi
  TelecommandStruct tc;
  tc.seconds = timestamp;
  tc.storeAddr = addr;
-  tc.requestId =
-      getRequestIdFromDataTC(data);  // TODO: Missing sanity check of the returned request id
+  tc.requestId = getRequestIdFromTc();  // TODO: Missing sanity check of the returned request id

  auto it = telecommandMap.insert(std::pair<uint32_t, TelecommandStruct>(timestamp, tc));
  if (it == telecommandMap.end()) {
@ -455,13 +451,10 @@ inline ReturnValue_t Service11TelecommandScheduling<MAX_NUM_TCS>::doFilterTimesh
 }

 template <size_t MAX_NUM_TCS>
-inline uint64_t Service11TelecommandScheduling<MAX_NUM_TCS>::getRequestIdFromDataTC(
-    const uint8_t *data) const {
-  TcPacketPus mask(data);
-
-  uint32_t sourceId = mask.getSourceId();
-  uint16_t apid = mask.getAPID();
-  uint16_t sequenceCount = mask.getPacketSequenceCount();
+inline uint64_t Service11TelecommandScheduling<MAX_NUM_TCS>::getRequestIdFromTc() const {
+  uint32_t sourceId = currentPacket.getSourceId();
+  uint16_t apid = currentPacket.getApid();
+  uint16_t sequenceCount = currentPacket.getSequenceCount();

  return buildRequestId(sourceId, apid, sequenceCount);
 }
--- a/src/fsfw/pus/Service17Test.cpp
+++ b/src/fsfw/pus/Service17Test.cpp
@ -1,39 +1,33 @@
 #include "fsfw/pus/Service17Test.h"

 #include "fsfw/FSFW.h"
+#include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/objectmanager/SystemObject.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
-#include "fsfw/tmtcpacket/pus/tm/TmPacketStored.h"
+#include "fsfw/tmtcservices/tmHelpers.h"

-Service17Test::Service17Test(object_id_t objectId, uint16_t apid, uint8_t serviceId)
-    : PusServiceBase(objectId, apid, serviceId), packetSubCounter(0) {}
+Service17Test::Service17Test(PsbParams params)
+    : PusServiceBase(params),
+      storeHelper(params.apid),
+      tmHelper(params.serviceId, storeHelper, sendHelper) {}

-Service17Test::~Service17Test() {}
+Service17Test::~Service17Test() = default;

 ReturnValue_t Service17Test::handleRequest(uint8_t subservice) {
  switch (subservice) {
    case Subservice::CONNECTION_TEST: {
-#if FSFW_USE_PUS_C_TELEMETRY == 0
-      TmPacketStoredPusA connectionPacket(apid, serviceId, Subservice::CONNECTION_TEST_REPORT,
-                                          packetSubCounter++);
-#else
-      TmPacketStoredPusC connectionPacket(apid, serviceId, Subservice::CONNECTION_TEST_REPORT,
-                                          packetSubCounter++);
-#endif
-      connectionPacket.sendPacket(requestQueue->getDefaultDestination(), requestQueue->getId());
-      return HasReturnvaluesIF::RETURN_OK;
+      ReturnValue_t result = tmHelper.prepareTmPacket(Subservice::CONNECTION_TEST_REPORT);
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+      }
+      return tmHelper.storeAndSendTmPacket();
    }
    case Subservice::EVENT_TRIGGER_TEST: {
-#if FSFW_USE_PUS_C_TELEMETRY == 0
-      TmPacketStoredPusA connectionPacket(apid, serviceId, Subservice::CONNECTION_TEST_REPORT,
-                                          packetSubCounter++);
-#else
-      TmPacketStoredPusC connectionPacket(apid, serviceId, Subservice::CONNECTION_TEST_REPORT,
-                                          packetSubCounter++);
-#endif
-      connectionPacket.sendPacket(requestQueue->getDefaultDestination(), requestQueue->getId());
      triggerEvent(TEST, 1234, 5678);
-      return RETURN_OK;
+      ReturnValue_t result = tmHelper.prepareTmPacket(Subservice::EVENT_TRIGGER_TEST);
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+      }
+      return tmHelper.storeAndSendTmPacket();
    }
    default:
      return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
@ -41,3 +35,23 @@ ReturnValue_t Service17Test::handleRequest(uint8_t subservice) {
 }

 ReturnValue_t Service17Test::performService() { return HasReturnvaluesIF::RETURN_OK; }
+
+ReturnValue_t Service17Test::initialize() {
+  ReturnValue_t result = PusServiceBase::initialize();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  initializeTmHelpers(sendHelper, storeHelper);
+  if (storeHelper.getTmStore() == nullptr) {
+    auto* tmStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TM_STORE);
+    if (tmStore == nullptr) {
+      return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
+    storeHelper.setTmStore(*tmStore);
+  }
+  return result;
+}
+
+void Service17Test::setCustomTmStore(StorageManagerIF& tmStore_) {
+  storeHelper.setTmStore(tmStore_);
+}
--- a/src/fsfw/pus/Service17Test.h
+++ b/src/fsfw/pus/Service17Test.h
@ -3,6 +3,8 @@

 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/tmtcservices/PusServiceBase.h"
+#include "fsfw/tmtcservices/TmStoreAndSendHelper.h"
+#include "fsfw/tmtcservices/TmStoreHelper.h"

 /**
 * @brief Test Service
@ -32,13 +34,19 @@ class Service17Test : public PusServiceBase {
    EVENT_TRIGGER_TEST = 128,
  };

-  Service17Test(object_id_t objectId, uint16_t apid, uint8_t serviceId);
-  virtual ~Service17Test();
-  virtual ReturnValue_t handleRequest(uint8_t subservice) override;
-  virtual ReturnValue_t performService() override;
+  explicit Service17Test(PsbParams params);
+
+  void setCustomTmStore(StorageManagerIF& tmStore);
+
+  ~Service17Test() override;
+  ReturnValue_t handleRequest(uint8_t subservice) override;
+  ReturnValue_t performService() override;
+  ReturnValue_t initialize() override;

 protected:
-  uint16_t packetSubCounter = 0;
+  TmStoreHelper storeHelper;
+  TmSendHelper sendHelper;
+  TmStoreAndSendWrapper tmHelper;
 };

 #endif /* FSFW_PUS_SERVICE17TEST_H_ */
--- a/src/fsfw/pus/Service1TelecommandVerification.cpp
+++ b/src/fsfw/pus/Service1TelecommandVerification.cpp
@ -3,22 +3,22 @@
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/pus/servicepackets/Service1Packets.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
-#include "fsfw/tmtcpacket/pus/tm/TmPacketStored.h"
 #include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
 #include "fsfw/tmtcservices/PusVerificationReport.h"
+#include "fsfw/tmtcservices/tmHelpers.h"

 Service1TelecommandVerification::Service1TelecommandVerification(object_id_t objectId,
                                                                 uint16_t apid, uint8_t serviceId,
                                                                 object_id_t targetDestination,
-                                                                 uint16_t messageQueueDepth)
+                                                                 uint16_t messageQueueDepth,
+                                                                 TimeStamperIF* timeStamper)
    : SystemObject(objectId),
      apid(apid),
      serviceId(serviceId),
-      targetDestination(targetDestination) {
-  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
-  tmQueue = QueueFactory::instance()->createMessageQueue(
-      messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+      targetDestination(targetDestination),
+      storeHelper(apid),
+      tmHelper(serviceId, storeHelper, sendHelper) {
+  tmQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
 }

 Service1TelecommandVerification::~Service1TelecommandVerification() {
@ -49,6 +49,19 @@ ReturnValue_t Service1TelecommandVerification::performOperation(uint8_t operatio
 ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
    PusVerificationMessage* message) {
  ReturnValue_t result;
+  uint8_t reportId = message->getReportId();
+  if (reportId == 0 or reportId > 8) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "Service1TelecommandVerification::sendVerificationReport: Invalid report ID "
+               << static_cast<int>(reportId) << " detected" << std::endl;
+#else
+    sif::printError(
+        "Service1TelecommandVerification::sendVerificationReport: Invalid report ID "
+        "%d detected\n",
+        reportId);
+#endif
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
  if (message->getReportId() % 2 == 0) {
    result = generateFailureReport(message);
  } else {
@ -69,32 +82,37 @@ ReturnValue_t Service1TelecommandVerification::generateFailureReport(
  FailureReport report(message->getReportId(), message->getTcPacketId(),
                       message->getTcSequenceControl(), message->getStep(), message->getErrorCode(),
                       message->getParameter1(), message->getParameter2());
-#if FSFW_USE_PUS_C_TELEMETRY == 0
-  TmPacketStoredPusA tmPacket(apid, serviceId, message->getReportId(), packetSubCounter++, &report);
-#else
-  TmPacketStoredPusC tmPacket(apid, serviceId, message->getReportId(), packetSubCounter++, &report);
-#endif
-  ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(), tmQueue->getId());
-  return result;
+  ReturnValue_t result =
+      storeHelper.preparePacket(serviceId, message->getReportId(), packetSubCounter++);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = storeHelper.setSourceDataSerializable(report);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  return tmHelper.storeAndSendTmPacket();
 }

 ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
    PusVerificationMessage* message) {
  SuccessReport report(message->getReportId(), message->getTcPacketId(),
                       message->getTcSequenceControl(), message->getStep());
-#if FSFW_USE_PUS_C_TELEMETRY == 0
-  TmPacketStoredPusA tmPacket(apid, serviceId, message->getReportId(), packetSubCounter++, &report);
-#else
-  TmPacketStoredPusC tmPacket(apid, serviceId, message->getReportId(), packetSubCounter++, &report);
-#endif
-  ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(), tmQueue->getId());
-  return result;
+  ReturnValue_t result =
+      storeHelper.preparePacket(serviceId, message->getReportId(), packetSubCounter++);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  result = storeHelper.setSourceDataSerializable(report);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  return tmHelper.storeAndSendTmPacket();
 }

 ReturnValue_t Service1TelecommandVerification::initialize() {
  // Get target object for TC verification messages
-  AcceptsTelemetryIF* funnel =
-      ObjectManager::instance()->get<AcceptsTelemetryIF>(targetDestination);
+  auto* funnel = ObjectManager::instance()->get<AcceptsTelemetryIF>(targetDestination);
  if (funnel == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "Service1TelecommandVerification::initialize: Specified"
@ -104,6 +122,33 @@ ReturnValue_t Service1TelecommandVerification::initialize() {
 #endif
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
+  if (tmQueue == nullptr) {
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
  tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
+  if (tmStore == nullptr) {
+    tmStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TM_STORE);
+    if (tmStore == nullptr) {
+      return ObjectManager::CHILD_INIT_FAILED;
+    }
+    storeHelper.setTmStore(*tmStore);
+  }
+  if (timeStamper == nullptr) {
+    timeStamper = ObjectManager::instance()->get<TimeStamperIF>(objects::TIME_STAMPER);
+    if (timeStamper == nullptr) {
+      return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
+  } else {
+  }
+  storeHelper.setTimeStamper(*timeStamper);
+
+  sendHelper.setMsgQueue(*tmQueue);
+  if (errReporter == nullptr) {
+    errReporter =
+        ObjectManager::instance()->get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
+    if (errReporter != nullptr) {
+      sendHelper.setInternalErrorReporter(*errReporter);
+    }
+  }
  return SystemObject::initialize();
 }
--- a/src/fsfw/pus/Service1TelecommandVerification.h
+++ b/src/fsfw/pus/Service1TelecommandVerification.h
@ -7,6 +7,9 @@
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tmtcservices/AcceptsVerifyMessageIF.h"
 #include "fsfw/tmtcservices/PusVerificationReport.h"
+#include "fsfw/tmtcservices/TmSendHelper.h"
+#include "fsfw/tmtcservices/TmStoreAndSendHelper.h"
+#include "fsfw/tmtcservices/TmStoreHelper.h"

 /**
 * @brief Verify TC acceptance, start, progress and execution.
@ -44,14 +47,15 @@ class Service1TelecommandVerification : public AcceptsVerifyMessageIF,
  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;

  Service1TelecommandVerification(object_id_t objectId, uint16_t apid, uint8_t serviceId,
-                                  object_id_t targetDestination, uint16_t messageQueueDepth);
-  virtual ~Service1TelecommandVerification();
+                                  object_id_t targetDestination, uint16_t messageQueueDepth,
+                                  TimeStamperIF* timeStamper = nullptr);
+  ~Service1TelecommandVerification() override;

  /**
   *
   * @return ID of Verification Queue
   */
-  virtual MessageQueueId_t getVerificationQueue() override;
+  MessageQueueId_t getVerificationQueue() override;

  /**
   * Performs the service periodically as specified in init_mission().
@ -59,7 +63,7 @@ class Service1TelecommandVerification : public AcceptsVerifyMessageIF,
   * @param operationCode
   * @return
   */
-  ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+  ReturnValue_t performOperation(uint8_t operationCode) override;

  /**
   * Initializes the destination for TC verification messages and initializes
@ -80,6 +84,12 @@ class Service1TelecommandVerification : public AcceptsVerifyMessageIF,

  uint16_t packetSubCounter = 0;

+  TmSendHelper sendHelper;
+  TmStoreHelper storeHelper;
+  TmStoreAndSendWrapper tmHelper;
+  InternalErrorReporterIF* errReporter = nullptr;
+  TimeStamperIF* timeStamper = nullptr;
+  StorageManagerIF* tmStore = nullptr;
  MessageQueueIF* tmQueue = nullptr;

  enum class Subservice : uint8_t {
--- a/src/fsfw/pus/Service20ParameterManagement.cpp
+++ b/src/fsfw/pus/Service20ParameterManagement.cpp
@ -14,7 +14,7 @@ Service20ParameterManagement::Service20ParameterManagement(object_id_t objectId,
    : CommandingServiceBase(objectId, apid, serviceId, numberOfParallelCommands,
                            commandTimeoutSeconds) {}

-Service20ParameterManagement::~Service20ParameterManagement() {}
+Service20ParameterManagement::~Service20ParameterManagement() = default;

 ReturnValue_t Service20ParameterManagement::isValidSubservice(uint8_t subservice) {
  switch (static_cast<Subservice>(subservice)) {
@ -64,8 +64,7 @@ ReturnValue_t Service20ParameterManagement::checkAndAcquireTargetID(object_id_t*
 ReturnValue_t Service20ParameterManagement::checkInterfaceAndAcquireMessageQueue(
    MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
  // check ReceivesParameterMessagesIF property of target
-  ReceivesParameterMessagesIF* possibleTarget =
-      ObjectManager::instance()->get<ReceivesParameterMessagesIF>(*objectId);
+  auto* possibleTarget = ObjectManager::instance()->get<ReceivesParameterMessagesIF>(*objectId);
  if (possibleTarget == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "Service20ParameterManagement::checkInterfaceAndAcquire"
@ -137,7 +136,7 @@ ReturnValue_t Service20ParameterManagement::prepareLoadCommand(CommandMessage* m
  if (parameterDataLen == 0) {
    return CommandingServiceBase::INVALID_TC;
  }
-  ReturnValue_t result = IPCStore->getFreeElement(&storeAddress, parameterDataLen, &storePointer);
+  ReturnValue_t result = ipcStore->getFreeElement(&storeAddress, parameterDataLen, &storePointer);
  if (result != HasReturnvaluesIF::RETURN_OK) {
    return result;
  }
@ -169,7 +168,7 @@ ReturnValue_t Service20ParameterManagement::handleReply(const CommandMessage* re

  switch (replyId) {
    case ParameterMessage::REPLY_PARAMETER_DUMP: {
-      ConstAccessorPair parameterData = IPCStore->getData(ParameterMessage::getStoreId(reply));
+      ConstAccessorPair parameterData = ipcStore->getData(ParameterMessage::getStoreId(reply));
      if (parameterData.first != HasReturnvaluesIF::RETURN_OK) {
        return HasReturnvaluesIF::RETURN_FAILED;
      }
@ -177,8 +176,7 @@ ReturnValue_t Service20ParameterManagement::handleReply(const CommandMessage* re
      ParameterId_t parameterId = ParameterMessage::getParameterId(reply);
      ParameterDumpReply parameterReply(objectId, parameterId, parameterData.second.data(),
                                        parameterData.second.size());
-      sendTmPacket(static_cast<uint8_t>(Subservice::PARAMETER_DUMP_REPLY), &parameterReply);
-      return HasReturnvaluesIF::RETURN_OK;
+      return sendTmPacket(static_cast<uint8_t>(Subservice::PARAMETER_DUMP_REPLY), parameterReply);
    }
    default:
      return CommandingServiceBase::INVALID_REPLY;
--- a/src/fsfw/pus/Service2DeviceAccess.cpp
+++ b/src/fsfw/pus/Service2DeviceAccess.cpp
@ -75,7 +75,7 @@ ReturnValue_t Service2DeviceAccess::prepareRawCommand(CommandMessage* messageToS
  // store command into the Inter Process Communication Store
  store_address_t storeAddress;
  ReturnValue_t result =
-      IPCStore->addData(&storeAddress, RawCommand.getCommand(), RawCommand.getCommandSize());
+      ipcStore->addData(&storeAddress, RawCommand.getCommand(), RawCommand.getCommandSize());
  DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet, storeAddress);
  return result;
 }
@ -135,8 +135,8 @@ void Service2DeviceAccess::sendWiretappingTm(CommandMessage* reply, uint8_t subs
  store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply);
  const uint8_t* data = nullptr;
  size_t size = 0;
-  ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
+  ReturnValue_t result = ipcStore->getData(storeAddress, &data, &size);
+  if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
                  "handleUnrequestedReply with failure ID "
@ -147,10 +147,12 @@ void Service2DeviceAccess::sendWiretappingTm(CommandMessage* reply, uint8_t subs

  // Init our dummy packet and correct endianness of object ID before
  // sending it back.
-  WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply), data);
-  TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId);
-  sendTmPacket(subservice, TmPacket.data, size, reinterpret_cast<uint8_t*>(&TmPacket.objectId),
-               sizeof(TmPacket.objectId));
+  WiretappingPacket tmPacket(DeviceHandlerMessage::getDeviceObjectId(reply), data);
+  result = sendTmPacket(subservice, tmPacket.objectId, tmPacket.data, size);
+  if (result != RETURN_OK) {
+    // TODO: Warning
+    return;
+  }
 }

 MessageQueueId_t Service2DeviceAccess::getDeviceQueue() { return commandQueue->getId(); }
--- a/src/fsfw/pus/Service3Housekeeping.cpp
+++ b/src/fsfw/pus/Service3Housekeeping.cpp
@ -294,14 +294,13 @@ ReturnValue_t Service3Housekeeping::generateHkReply(const CommandMessage* hkMess
  store_address_t storeId;

  sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId);
-  auto resultPair = IPCStore->getData(storeId);
+  auto resultPair = ipcStore->getData(storeId);
  if (resultPair.first != HasReturnvaluesIF::RETURN_OK) {
    return resultPair.first;
  }

  HkPacket hkPacket(sid, resultPair.second.data(), resultPair.second.size());
-  return sendTmPacket(static_cast<uint8_t>(subserviceId), hkPacket.hkData, hkPacket.hkSize, nullptr,
-                      0);
+  return sendTmPacket(static_cast<uint8_t>(subserviceId), hkPacket.hkData, hkPacket.hkSize);
 }

 sid_t Service3Housekeeping::buildSid(object_id_t objectId, const uint8_t** tcData,
--- a/src/fsfw/pus/Service5EventReporting.cpp
+++ b/src/fsfw/pus/Service5EventReporting.cpp
@ -5,12 +5,13 @@
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/pus/servicepackets/Service5Packets.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
-#include "fsfw/tmtcpacket/pus/tm/TmPacketStored.h"
+#include "fsfw/tmtcservices/tmHelpers.h"

-Service5EventReporting::Service5EventReporting(object_id_t objectId, uint16_t apid,
-                                               uint8_t serviceId, size_t maxNumberReportsPerCycle,
+Service5EventReporting::Service5EventReporting(PsbParams params, size_t maxNumberReportsPerCycle,
                                               uint32_t messageQueueDepth)
-    : PusServiceBase(objectId, apid, serviceId),
+    : PusServiceBase(params),
+      storeHelper(params.apid),
+      tmHelper(params.serviceId, storeHelper, sendHelper),
      maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
  eventQueue = QueueFactory::instance()->createMessageQueue(
@ -44,15 +45,9 @@ ReturnValue_t Service5EventReporting::performService() {
 ReturnValue_t Service5EventReporting::generateEventReport(EventMessage message) {
  EventReport report(message.getEventId(), message.getReporter(), message.getParameter1(),
                     message.getParameter2());
-#if FSFW_USE_PUS_C_TELEMETRY == 0
-  TmPacketStoredPusA tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
-                              message.getSeverity(), packetSubCounter++, &report);
-#else
-  TmPacketStoredPusC tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
-                              message.getSeverity(), packetSubCounter++, &report);
-#endif
-  ReturnValue_t result =
-      tmPacket.sendPacket(requestQueue->getDefaultDestination(), requestQueue->getId());
+  storeHelper.preparePacket(psbParams.serviceId, message.getSeverity(), tmHelper.sendCounter);
+  storeHelper.setSourceDataSerializable(report);
+  ReturnValue_t result = tmHelper.storeAndSendTmPacket();
  if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "Service5EventReporting::generateEventReport: "
@ -85,14 +80,19 @@ ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
 // In addition to the default PUSServiceBase initialization, this service needs
 // to be registered to the event manager to listen for events.
 ReturnValue_t Service5EventReporting::initialize() {
+  ReturnValue_t result = PusServiceBase::initialize();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
  auto* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
  if (manager == nullptr) {
    return RETURN_FAILED;
  }
  // register Service 5 as listener for events
-  ReturnValue_t result = manager->registerListener(eventQueue->getId(), true);
+  result = manager->registerListener(eventQueue->getId(), true);
  if (result != HasReturnvaluesIF::RETURN_OK) {
    return result;
  }
-  return PusServiceBase::initialize();
+  initializeTmHelpers(sendHelper, storeHelper);
+  return result;
 }
--- a/src/fsfw/pus/Service5EventReporting.h
+++ b/src/fsfw/pus/Service5EventReporting.h
@ -3,6 +3,7 @@

 #include "fsfw/events/EventMessage.h"
 #include "fsfw/tmtcservices/PusServiceBase.h"
+#include "fsfw/tmtcservices/TmStoreAndSendHelper.h"

 /**
 * @brief Report on-board events like information or errors
@ -40,9 +41,9 @@
 */
 class Service5EventReporting : public PusServiceBase {
 public:
-  Service5EventReporting(object_id_t objectId, uint16_t apid, uint8_t serviceId,
-                         size_t maxNumberReportsPerCycle, uint32_t messageQueueDepth);
-  virtual ~Service5EventReporting();
+  Service5EventReporting(PsbParams params, size_t maxNumberReportsPerCycle = 10,
+                         uint32_t messageQueueDepth = 10);
+  ~Service5EventReporting() override;

  /***
   * Check for events and generate event reports if required.
@ -74,9 +75,11 @@ class Service5EventReporting : public PusServiceBase {
  };

 private:
-  uint16_t packetSubCounter = 0;
  MessageQueueIF* eventQueue = nullptr;
  bool enableEventReport = true;
+  TmSendHelper sendHelper;
+  TmStoreHelper storeHelper;
+  TmStoreAndSendWrapper tmHelper;
  const uint8_t maxNumberReportsPerCycle;

  ReturnValue_t generateEventReport(EventMessage message);
--- a/src/fsfw/pus/Service8FunctionManagement.cpp
+++ b/src/fsfw/pus/Service8FunctionManagement.cpp
@ -78,7 +78,7 @@ ReturnValue_t Service8FunctionManagement::prepareDirectCommand(CommandMessage* m
  // store additional parameters into the IPC Store
  store_address_t parameterAddress;
  ReturnValue_t result =
-      IPCStore->addData(&parameterAddress, command.getParameters(), command.getParametersSize());
+      ipcStore->addData(&parameterAddress, command.getParameters(), command.getParametersSize());

  // setCommand expects a Command Message, an Action ID and a store adress
  // pointing to additional parameters
@ -130,7 +130,7 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(const CommandMessage*
  store_address_t storeId = ActionMessage::getStoreId(reply);
  size_t size = 0;
  const uint8_t* buffer = nullptr;
-  ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size);
+  ReturnValue_t result = ipcStore->getData(storeId, &buffer, &size);
  if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "Service 8: Could not retrieve data for data reply" << std::endl;
@ -138,9 +138,9 @@ ReturnValue_t Service8FunctionManagement::handleDataReply(const CommandMessage*
    return result;
  }
  DataReply dataReply(objectId, actionId, buffer, size);
-  result = sendTmPacket(static_cast<uint8_t>(Subservice::REPLY_DIRECT_COMMANDING_DATA), &dataReply);
+  result = sendTmPacket(static_cast<uint8_t>(Subservice::REPLY_DIRECT_COMMANDING_DATA), dataReply);

-  auto deletionResult = IPCStore->deleteData(storeId);
+  auto deletionResult = ipcStore->deleteData(storeId);
  if (deletionResult != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "Service8FunctionManagement::handleReply: Deletion"
--- a/src/fsfw/pus/Service8FunctionManagement.h
+++ b/src/fsfw/pus/Service8FunctionManagement.h
@ -32,7 +32,7 @@ class Service8FunctionManagement : public CommandingServiceBase {
 public:
  Service8FunctionManagement(object_id_t objectId, uint16_t apid, uint8_t serviceId,
                             uint8_t numParallelCommands = 4, uint16_t commandTimeoutSeconds = 60);
-  virtual ~Service8FunctionManagement();
+  ~Service8FunctionManagement() override;

 protected:
  /* CSB abstract functions implementation . See CSB documentation. */
--- a/src/fsfw/pus/Service9TimeManagement.cpp
+++ b/src/fsfw/pus/Service9TimeManagement.cpp
@ -5,11 +5,9 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/timemanager/CCSDSTime.h"

-Service9TimeManagement::Service9TimeManagement(object_id_t objectId, uint16_t apid,
-                                               uint8_t serviceId)
-    : PusServiceBase(objectId, apid, serviceId) {}
+Service9TimeManagement::Service9TimeManagement(PsbParams params) : PusServiceBase(params) {}

-Service9TimeManagement::~Service9TimeManagement() {}
+Service9TimeManagement::~Service9TimeManagement() = default;

 ReturnValue_t Service9TimeManagement::performService() { return RETURN_OK; }

@ -25,7 +23,7 @@ ReturnValue_t Service9TimeManagement::handleRequest(uint8_t subservice) {

 ReturnValue_t Service9TimeManagement::setTime() {
  Clock::TimeOfDay_t timeToSet;
-  TimePacket timePacket(currentPacket.getApplicationData(), currentPacket.getApplicationDataSize());
+  TimePacket timePacket(currentPacket.getUserData(), currentPacket.getUserDataLen());
  ReturnValue_t result =
      CCSDSTime::convertFromCcsds(&timeToSet, timePacket.getTime(), timePacket.getTimeSize());
  if (result != RETURN_OK) {
--- a/src/fsfw/pus/Service9TimeManagement.h
+++ b/src/fsfw/pus/Service9TimeManagement.h
@ -16,16 +16,16 @@ class Service9TimeManagement : public PusServiceBase {
  /**
   * 	@brief This service provides the capability to set the on-board time.
   */
-  Service9TimeManagement(object_id_t objectId, uint16_t apid, uint8_t serviceId);
+  explicit Service9TimeManagement(PsbParams params);

-  virtual ~Service9TimeManagement();
+  ~Service9TimeManagement() override;

-  virtual ReturnValue_t performService() override;
+  ReturnValue_t performService() override;

  /**
   * 	@brief Sets the onboard-time by retrieving the time to set from TC[9,128].
   */
-  virtual ReturnValue_t handleRequest(uint8_t subservice) override;
+  ReturnValue_t handleRequest(uint8_t subservice) override;

  virtual ReturnValue_t setTime();

--- a/src/fsfw/pus/servicepackets/Service1Packets.h
+++ b/src/fsfw/pus/servicepackets/Service1Packets.h
@ -50,7 +50,7 @@ class FailureReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 2, 4, 6
    if (result != HasReturnvaluesIF::RETURN_OK) {
      return result;
    }
-    if (failureSubtype == tc_verification::PROGRESS_FAILURE) {
+    if (failureSubtype == tcverif::PROGRESS_FAILURE) {
      result = SerializeAdapter::serialize(&stepNumber, buffer, size, maxSize, streamEndianness);
      if (result != HasReturnvaluesIF::RETURN_OK) {
        return result;
@ -73,7 +73,7 @@ class FailureReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 2, 4, 6
    size_t size = 0;
    size += SerializeAdapter::getSerializedSize(&packetId);
    size += sizeof(packetSequenceControl);
-    if (failureSubtype == tc_verification::PROGRESS_FAILURE) {
+    if (failureSubtype == tcverif::PROGRESS_FAILURE) {
      size += SerializeAdapter::getSerializedSize(&stepNumber);
    }
    size += SerializeAdapter::getSerializedSize(&errorCode);
@ -130,7 +130,7 @@ class SuccessReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 3, 5
    if (result != HasReturnvaluesIF::RETURN_OK) {
      return result;
    }
-    if (subtype == tc_verification::PROGRESS_SUCCESS) {
+    if (subtype == tcverif::PROGRESS_SUCCESS) {
      result = SerializeAdapter::serialize(&stepNumber, buffer, size, maxSize, streamEndianness);
      if (result != HasReturnvaluesIF::RETURN_OK) {
        return result;
@ -143,7 +143,7 @@ class SuccessReport : public SerializeIF {  //!< [EXPORT] : [SUBSERVICE] 1, 3, 5
    size_t size = 0;
    size += SerializeAdapter::getSerializedSize(&packetId);
    size += sizeof(packetSequenceControl);
-    if (subtype == tc_verification::PROGRESS_SUCCESS) {
+    if (subtype == tcverif::PROGRESS_SUCCESS) {
      size += SerializeAdapter::getSerializedSize(&stepNumber);
    }
    return size;
--- a/src/fsfw/pus/servicepackets/Service9Packets.h
+++ b/src/fsfw/pus/servicepackets/Service9Packets.h
@ -1,7 +1,7 @@
 #ifndef FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_
 #define FSFW_PUS_SERVICEPACKETS_SERVICE9PACKETS_H_

-#include "../../serialize/SerialLinkedListAdapter.h"
+#include "fsfw/serialize/SerialLinkedListAdapter.h"

 /**
 * @brief Subservice 128
@ -11,16 +11,16 @@
 */
 class TimePacket : SerialLinkedListAdapter<SerializeIF> {  //!< [EXPORT] : [SUBSERVICE] 128
 public:
+  TimePacket(const TimePacket& command) = delete;
  TimePacket(const uint8_t* timeBuffer_, uint32_t timeSize_) {
    timeBuffer = timeBuffer_;
    timeSize = timeSize_;
  }
  const uint8_t* getTime() { return timeBuffer; }

-  uint32_t getTimeSize() const { return timeSize; }
+  [[nodiscard]] uint32_t getTimeSize() const { return timeSize; }

 private:
-  TimePacket(const TimePacket& command);
  const uint8_t* timeBuffer;
  uint32_t timeSize;  //!< [EXPORT] : [IGNORE]
 };
--- a/src/fsfw/returnvalues/FwClassIds.h
+++ b/src/fsfw/returnvalues/FwClassIds.h
@ -34,9 +34,10 @@ enum : uint8_t {
  FIFO_CLASS,                     // FF
  MESSAGE_PROXY,                  // MQP
  TRIPLE_REDUNDACY_CHECK,         // TRC
-  TC_PACKET_CHECK,                // TCC
+  PACKET_CHECK,                   // TCC
  PACKET_DISTRIBUTION,            // TCD
-  ACCEPTS_TELECOMMANDS_IF,        // PUS
+  ACCEPTS_TELECOMMANDS_IF,        // ATC
+  PUS_IF,                         // PUS
  DEVICE_SERVICE_BASE,            // DSB
  COMMAND_SERVICE_BASE,           // CSB
  TM_STORE_BACKEND_IF,            // TMB
--- a/src/fsfw/returnvalues/HasReturnvaluesIF.h
+++ b/src/fsfw/returnvalues/HasReturnvaluesIF.h
@ -10,11 +10,21 @@
 #define MAKE_RETURN_CODE(number) ((INTERFACE_ID << 8) + (number))
 typedef uint16_t ReturnValue_t;

+namespace result {
+static constexpr ReturnValue_t OK = 0;
+static constexpr ReturnValue_t FAILED = 1;
+
+static constexpr ReturnValue_t makeCode(uint8_t classId, uint8_t number) {
+  return (static_cast<ReturnValue_t>(classId) << 8) + number;
+}
+}  // namespace result
+
 class HasReturnvaluesIF {
 public:
-  static const ReturnValue_t RETURN_OK = 0;
-  static const ReturnValue_t RETURN_FAILED = 1;
-  virtual ~HasReturnvaluesIF() {}
+  static const ReturnValue_t RETURN_OK = result::OK;
+  static const ReturnValue_t RETURN_FAILED = result::FAILED;
+
+  virtual ~HasReturnvaluesIF() = default;

  /**
   * It is discouraged to use the input parameters 0,0 and 0,1 as this
@ -24,7 +34,7 @@ class HasReturnvaluesIF {
   * @return
   */
  static constexpr ReturnValue_t makeReturnCode(uint8_t classId, uint8_t number) {
-    return (static_cast<ReturnValue_t>(classId) << 8) + number;
+    return result::makeCode(classId, number);
  }
 };

--- a/src/fsfw/retval.h
+++ b/src/fsfw/retval.h
@ -0,0 +1,6 @@
+#ifndef FSFW_RETVAL_H
+#define FSFW_RETVAL_H
+
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
+#endif  // FSFW_RETVAL_H
--- a/src/fsfw/serialize.h
+++ b/src/fsfw/serialize.h
@ -1,10 +1,10 @@
-#ifndef FSFW_INC_FSFW_SERIALIZE_H_
-#define FSFW_INC_FSFW_SERIALIZE_H_
+#ifndef FSFW_SERIALIZE_H_
+#define FSFW_SERIALIZE_H_

-#include "fsfw/serialize/EndianConverter.h"
-#include "fsfw/serialize/SerialArrayListAdapter.h"
-#include "fsfw/serialize/SerialBufferAdapter.h"
-#include "fsfw/serialize/SerialLinkedListAdapter.h"
-#include "fsfw/serialize/SerializeElement.h"
+#include "serialize/EndianConverter.h"
+#include "serialize/SerialArrayListAdapter.h"
+#include "serialize/SerialBufferAdapter.h"
+#include "serialize/SerialLinkedListAdapter.h"
+#include "serialize/SerializeElement.h"

-#endif /* FSFW_INC_FSFW_SERIALIZE_H_ */
+#endif /* FSFW_SERIALIZE_H_ */
--- a/src/fsfw/serialize/SerializeAdapter.h
+++ b/src/fsfw/serialize/SerializeAdapter.h
@ -74,7 +74,7 @@ class SerializeAdapter {
      return HasReturnvaluesIF::RETURN_FAILED;
    }
    InternalSerializeAdapter<T, std::is_base_of<SerializeIF, T>::value> adapter;
-    uint8_t **tempPtr = const_cast<uint8_t **>(&buffer);
+    auto **tempPtr = const_cast<uint8_t **>(&buffer);
    size_t tmpSize = 0;
    ReturnValue_t result = adapter.serialize(object, tempPtr, &tmpSize, maxSize, streamEndianness);
    if (serSize != nullptr) {
@ -232,7 +232,7 @@ class SerializeAdapter {
      }
    }

-    uint32_t getSerializedSize(const T *object) { return sizeof(T); }
+    uint32_t getSerializedSize(const T *) { return sizeof(T); }
  };

  /**
--- a/src/fsfw/storagemanager/LocalPool.cpp
+++ b/src/fsfw/storagemanager/LocalPool.cpp
@ -194,8 +194,6 @@ void LocalPool::clearStore() {
    for (auto& size : sizeList) {
      size = STORAGE_FREE;
    }
-    //        std::memset(sizeList[index], 0xff,
-    //                numberOfElements[index] * sizeof(size_type));
  }
 }

@ -338,3 +336,16 @@ void LocalPool::clearSubPool(max_subpools_t subpoolIndex) {
 }

 LocalPool::max_subpools_t LocalPool::getNumberOfSubPools() const { return NUMBER_OF_SUBPOOLS; }
+
+bool LocalPool::hasDataAtId(store_address_t storeId) const {
+  if (storeId.poolIndex >= NUMBER_OF_SUBPOOLS) {
+    return false;
+  }
+  if ((storeId.packetIndex >= numberOfElements[storeId.poolIndex])) {
+    return false;
+  }
+  if (sizeLists[storeId.poolIndex][storeId.packetIndex] != STORAGE_FREE) {
+    return true;
+  }
+  return false;
+}
--- a/src/fsfw/storagemanager/LocalPool.h
+++ b/src/fsfw/storagemanager/LocalPool.h
@ -81,7 +81,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
  /**
   * @brief	In the LocalPool's destructor all allocated memory is freed.
   */
-  virtual ~LocalPool(void);
+  ~LocalPool() override;

  /**
   * Documentation: See StorageManagerIF.h
@ -132,6 +132,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
   * @return
   */
  max_subpools_t getNumberOfSubPools() const override;
+  bool hasDataAtId(store_address_t storeId) const override;

 protected:
  /**
--- a/src/fsfw/storagemanager/PoolManager.cpp
+++ b/src/fsfw/storagemanager/PoolManager.cpp
@ -7,7 +7,7 @@ PoolManager::PoolManager(object_id_t setObjectId, const LocalPoolConfig& localPo
  mutex = MutexFactory::instance()->createMutex();
 }

-PoolManager::~PoolManager(void) { MutexFactory::instance()->deleteMutex(mutex); }
+PoolManager::~PoolManager() { MutexFactory::instance()->deleteMutex(mutex); }

 ReturnValue_t PoolManager::reserveSpace(const size_t size, store_address_t* address,
                                        bool ignoreFault) {
@ -17,7 +17,7 @@ ReturnValue_t PoolManager::reserveSpace(const size_t size, store_address_t* addr
 }

 ReturnValue_t PoolManager::deleteData(store_address_t storeId) {
-#if FSFW_VERBOSE_LEVEL >= 2
+#if FSFW_VERBOSE_LEVEL >= 2 && FSFW_OBJ_EVENT_TRANSLATION == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
  sif::debug << "PoolManager( " << translateObject(getObjectId()) << " )::deleteData from store "
             << storeId.poolIndex << ". id is " << storeId.packetIndex << std::endl;
--- a/src/fsfw/storagemanager/StorageManagerIF.h
+++ b/src/fsfw/storagemanager/StorageManagerIF.h
@ -55,7 +55,7 @@ class StorageManagerIF : public HasReturnvaluesIF {
  /**
   * @brief This is the empty virtual destructor as required for C++ interfaces.
   */
-  virtual ~StorageManagerIF(){};
+  ~StorageManagerIF() override = default;
  /**
   * @brief	With addData, a free storage position is allocated and data
   * 			stored there.
@ -160,8 +160,10 @@ class StorageManagerIF : public HasReturnvaluesIF {
   * 					@li	RETURN_FAILED if data could not be added.
   * 						storageId is unchanged then.
   */
-  virtual ReturnValue_t getFreeElement(store_address_t* storageId, const size_t size,
-                                       uint8_t** p_data, bool ignoreFault = false) = 0;
+  virtual ReturnValue_t getFreeElement(store_address_t* storageId, size_t size, uint8_t** p_data,
+                                       bool ignoreFault = false) = 0;
+
+  [[nodiscard]] virtual bool hasDataAtId(store_address_t storeId) const = 0;

  /**
   * Clears the whole store.
@ -192,7 +194,7 @@ class StorageManagerIF : public HasReturnvaluesIF {
   * Get number of pools.
   * @return
   */
-  virtual max_subpools_t getNumberOfSubPools() const = 0;
+  [[nodiscard]] virtual max_subpools_t getNumberOfSubPools() const = 0;
 };

 #endif /* FSFW_STORAGEMANAGER_STORAGEMANAGERIF_H_ */
--- a/src/fsfw/storagemanager/storeAddress.h
+++ b/src/fsfw/storagemanager/storeAddress.h
@ -3,26 +3,26 @@

 #include <cstdint>

-namespace storeId {
-static constexpr uint32_t INVALID_STORE_ADDRESS = 0xffffffff;
-}
-
 /**
 * This union defines the type that identifies where a data packet is
 * stored in the store. It comprises of a raw part to read it as raw value and
 * a structured part to use it in pool-like stores.
 */
 union store_address_t {
+ public:
+  static constexpr uint32_t INVALID_RAW = 0xffffffff;
  /**
   * Default Constructor, initializing to INVALID_ADDRESS
   */
-  store_address_t() : raw(storeId::INVALID_STORE_ADDRESS) {}
+  store_address_t() : raw(INVALID_RAW) {}
  /**
   * Constructor to create an address object using the raw address
   *
   * @param rawAddress
   */
-  store_address_t(uint32_t rawAddress) : raw(rawAddress) {}
+  explicit store_address_t(uint32_t rawAddress) : raw(rawAddress) {}
+
+  static store_address_t invalid() { return {}; };

  /**
   * Constructor to create an address object using pool
@ -52,6 +52,12 @@ union store_address_t {
  uint32_t raw;

  bool operator==(const store_address_t& other) const { return raw == other.raw; }
+  bool operator!=(const store_address_t& other) const { return raw != other.raw; }
+
+  store_address_t& operator=(const uint32_t rawAddr) {
+    raw = rawAddr;
+    return *this;
+  }
 };

 #endif /* FSFW_STORAGEMANAGER_STOREADDRESS_H_ */
--- a/src/fsfw/tasks/FixedTimeslotTaskIF.h
+++ b/src/fsfw/tasks/FixedTimeslotTaskIF.h
@ -15,7 +15,7 @@ class FixedTimeslotTaskIF : public PeriodicTaskIF {
  ~FixedTimeslotTaskIF() override = default;

  static constexpr ReturnValue_t SLOT_LIST_EMPTY =
-      HasReturnvaluesIF::makeReturnCode(CLASS_ID::FIXED_SLOT_TASK_IF, 0);
+      result::makeCode(CLASS_ID::FIXED_SLOT_TASK_IF, 0);

  /**
   * Add an object with a slot time and the execution step to the task.
--- a/src/fsfw/tcdistribution/CCSDSDistributor.cpp
+++ b/src/fsfw/tcdistribution/CCSDSDistributor.cpp
@ -2,12 +2,13 @@

 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
-#include "fsfw/tmtcpacket/SpacePacketBase.h"
+#include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"

 #define CCSDS_DISTRIBUTOR_DEBUGGING 0

-CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId)
-    : TcDistributor(setObjectId), defaultApid(setDefaultApid) {}
+CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId,
+                                   CcsdsPacketCheckIF* packetChecker)
+    : TcDistributor(setObjectId), defaultApid(setDefaultApid), packetChecker(packetChecker) {}

 CCSDSDistributor::~CCSDSDistributor() = default;

@ -25,7 +26,7 @@ TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
 #endif
  const uint8_t* packet = nullptr;
  size_t size = 0;
-  ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(), &packet, &size);
+  ReturnValue_t result = tcStore->getData(currentMessage.getStorageId(), &packet, &size);
  if (result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@ -40,19 +41,21 @@ TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
 #endif
    return queueMap.end();
  }
-  SpacePacketBase currentPacket(packet);
-
+  SpacePacketReader currentPacket(packet, size);
+  result = packetChecker->checkPacket(currentPacket, size);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+  }
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && CCSDS_DISTRIBUTOR_DEBUGGING == 1
-  sif::info << "CCSDSDistributor::selectDestination has packet with APID " << std::hex
-            << currentPacket.getAPID() << std::dec << std::endl;
+  sif::info << "CCSDSDistributor::selectDestination has packet with APID 0x" << std::hex
+            << currentPacket.getApid() << std::dec << std::endl;
 #endif
-  auto position = this->queueMap.find(currentPacket.getAPID());
+  auto position = this->queueMap.find(currentPacket.getApid());
  if (position != this->queueMap.end()) {
    return position;
  } else {
    // The APID was not found. Forward packet to main SW-APID anyway to
    //  create acceptance failure report.
-    return this->queueMap.find(this->defaultApid);
+    return queueMap.find(this->defaultApid);
  }
 }

@ -80,6 +83,9 @@ ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid, MessageQueueI
 uint16_t CCSDSDistributor::getIdentifier() { return 0; }

 ReturnValue_t CCSDSDistributor::initialize() {
+  if (packetChecker == nullptr) {
+    packetChecker = new CcsdsPacketChecker(ccsds::PacketType::TC);
+  }
  ReturnValue_t status = this->TcDistributor::initialize();
  this->tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
  if (this->tcStore == nullptr) {
--- a/src/fsfw/tcdistribution/CCSDSDistributor.h
+++ b/src/fsfw/tcdistribution/CCSDSDistributor.h
@ -1,11 +1,12 @@
 #ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
 #define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_

-#include "../objectmanager/ObjectManagerIF.h"
-#include "../storagemanager/StorageManagerIF.h"
-#include "../tcdistribution/CCSDSDistributorIF.h"
-#include "../tcdistribution/TcDistributor.h"
-#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "fsfw/objectmanager/ObjectManagerIF.h"
+#include "fsfw/storagemanager/StorageManagerIF.h"
+#include "fsfw/tcdistribution/CCSDSDistributorIF.h"
+#include "fsfw/tcdistribution/CcsdsPacketChecker.h"
+#include "fsfw/tcdistribution/TcDistributor.h"
+#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"

 /**
 * @brief 	An instantiation of the CCSDSDistributorIF.
@ -24,14 +25,15 @@ class CCSDSDistributor : public TcDistributor,
   * 			TcDistributor ctor with a certain object id.
   * @details
   * @c tcStore is set in the @c initialize method.
-   * @param setDefaultApid The default APID, where packets with unknown
+   * @param unknownApid The default APID, where packets with unknown
   * destination are sent to.
   */
-  CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId);
+  CCSDSDistributor(uint16_t unknownApid, object_id_t setObjectId,
+                   CcsdsPacketCheckIF* packetChecker = nullptr);
  /**
   * The destructor is empty.
   */
-  virtual ~CCSDSDistributor();
+  ~CCSDSDistributor() override;

  MessageQueueId_t getRequestQueue() override;
  ReturnValue_t registerApplication(uint16_t apid, MessageQueueId_t id) override;
@ -63,6 +65,8 @@ class CCSDSDistributor : public TcDistributor,
   * pure Space Packets and there exists no SpacePacketStored class.
   */
  StorageManagerIF* tcStore = nullptr;
+
+  CcsdsPacketCheckIF* packetChecker = nullptr;
 };

 #endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */
--- a/src/fsfw/tcdistribution/CCSDSDistributorIF.h
+++ b/src/fsfw/tcdistribution/CCSDSDistributorIF.h
@ -34,7 +34,7 @@ class CCSDSDistributorIF {
  /**
   * The empty virtual destructor.
   */
-  virtual ~CCSDSDistributorIF() {}
+  virtual ~CCSDSDistributorIF() = default;
 };

 #endif /* FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_ */
--- a/src/fsfw/tcdistribution/CFDPDistributor.cpp
+++ b/src/fsfw/tcdistribution/CFDPDistributor.cpp
@ -2,7 +2,7 @@

 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/tcdistribution/CCSDSDistributorIF.h"
-#include "fsfw/tmtcpacket/cfdp/CFDPPacketStored.h"
+#include "fsfw/tmtcpacket/cfdp/CfdpPacketStored.h"

 #ifndef FSFW_CFDP_DISTRIBUTOR_DEBUGGING
 #define FSFW_CFDP_DISTRIBUTOR_DEBUGGING 1
@ -16,7 +16,7 @@ CFDPDistributor::CFDPDistributor(uint16_t setApid, object_id_t setObjectId,
      tcStatus(RETURN_FAILED),
      packetSource(setPacketSource) {}

-CFDPDistributor::~CFDPDistributor() {}
+CFDPDistributor::~CFDPDistributor() = default;

 CFDPDistributor::TcMqMapIter CFDPDistributor::selectDestination() {
 #if FSFW_CFDP_DISTRIBUTOR_DEBUGGING == 1
@ -29,13 +29,13 @@ CFDPDistributor::TcMqMapIter CFDPDistributor::selectDestination() {
                  storeId.packetIndex);
 #endif
 #endif
-  TcMqMapIter queueMapIt = this->queueMap.end();
+  auto queueMapIt = this->queueMap.end();
  if (this->currentPacket == nullptr) {
    return queueMapIt;
  }
  this->currentPacket->setStoreAddress(this->currentMessage.getStorageId());
-  if (currentPacket->getWholeData() != nullptr) {
-    tcStatus = checker.checkPacket(currentPacket);
+  if (currentPacket->getFullData() != nullptr) {
+    tcStatus = checker.checkPacket(*currentPacket, currentPacket->getFullPacketLen());
    if (tcStatus != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@ -72,7 +72,7 @@ CFDPDistributor::TcMqMapIter CFDPDistributor::selectDestination() {

 ReturnValue_t CFDPDistributor::registerHandler(AcceptsTelecommandsIF* handler) {
  uint16_t handlerId =
-      handler->getIdentifier();  // should be 0, because CFDPHandler does not set a set a service-ID
+      handler->getIdentifier();  // should be 0, because CfdpHandler does not set a set a service-ID
 #if FSFW_CFDP_DISTRIBUTOR_DEBUGGING == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
  sif::info << "CFDPDistributor::registerHandler: Handler ID: " << static_cast<int>(handlerId)
@ -121,14 +121,13 @@ MessageQueueId_t CFDPDistributor::getRequestQueue() { return tcQueue->getId(); }
 uint16_t CFDPDistributor::getIdentifier() { return this->apid; }

 ReturnValue_t CFDPDistributor::initialize() {
-  currentPacket = new CFDPPacketStored();
+  currentPacket = new CfdpPacketStored();
  if (currentPacket == nullptr) {
    // Should not happen, memory allocation failed!
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }

-  CCSDSDistributorIF* ccsdsDistributor =
-      ObjectManager::instance()->get<CCSDSDistributorIF>(packetSource);
+  auto* ccsdsDistributor = ObjectManager::instance()->get<CCSDSDistributorIF>(packetSource);
  if (ccsdsDistributor == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "CFDPDistributor::initialize: Packet source invalid" << std::endl;
--- a/src/fsfw/tcdistribution/CFDPDistributor.h
+++ b/src/fsfw/tcdistribution/CFDPDistributor.h
@ -1,10 +1,10 @@
 #ifndef FSFW_TCDISTRIBUTION_CFDPDISTRIBUTOR_H_
 #define FSFW_TCDISTRIBUTION_CFDPDISTRIBUTOR_H_

-#include <fsfw/tcdistribution/TcPacketCheckCFDP.h>
+#include <fsfw/tcdistribution/CfdpPacketChecker.h>

 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tmtcpacket/cfdp/CFDPPacketStored.h"
+#include "../tmtcpacket/cfdp/CfdpPacketStored.h"
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../tmtcservices/VerificationReporter.h"
 #include "CFDPDistributorIF.h"
@ -31,7 +31,7 @@ class CFDPDistributor : public TcDistributor,
  /**
   * The destructor is empty.
   */
-  virtual ~CFDPDistributor();
+  ~CFDPDistributor() override;
  ReturnValue_t registerHandler(AcceptsTelecommandsIF* handler) override;
  MessageQueueId_t getRequestQueue() override;
  ReturnValue_t initialize() override;
@ -42,8 +42,8 @@ class CFDPDistributor : public TcDistributor,
  /**
   * The currently handled packet is stored here.
   */
-  CFDPPacketStored* currentPacket = nullptr;
-  TcPacketCheckCFDP checker;
+  CfdpPacketStored* currentPacket = nullptr;
+  CfdpPacketChecker checker;
  /**
   * With this variable, the current check status is stored to generate
   * acceptance messages later.
--- a/src/fsfw/tcdistribution/CFDPDistributorIF.h
+++ b/src/fsfw/tcdistribution/CFDPDistributorIF.h
@ -13,7 +13,7 @@ class CFDPDistributorIF {
  /**
   * The empty virtual destructor.
   */
-  virtual ~CFDPDistributorIF() {}
+  virtual ~CFDPDistributorIF() = default;
  /**
   * With this method, Handlers can register themselves at the CFDP Distributor.
   * @param handler A pointer to the registering Handler.
--- a/src/fsfw/tcdistribution/CMakeLists.txt
+++ b/src/fsfw/tcdistribution/CMakeLists.txt
@ -1,4 +1,9 @@
 target_sources(
  ${LIB_FSFW_NAME}
-  PRIVATE CCSDSDistributor.cpp PUSDistributor.cpp TcDistributor.cpp
-          TcPacketCheckPUS.cpp TcPacketCheckCFDP.cpp CFDPDistributor.cpp)
+  PRIVATE CCSDSDistributor.cpp
+          PusDistributor.cpp
+          TcDistributor.cpp
+          PusPacketChecker.cpp
+          TcPacketCheckCFDP.cpp
+          CFDPDistributor.cpp
+          CcsdsPacketChecker.cpp)
--- a/src/fsfw/tcdistribution/CcsdsPacketCheckIF.h
+++ b/src/fsfw/tcdistribution/CcsdsPacketCheckIF.h
@ -1,30 +1,32 @@
 #ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKIF_H_
 #define FSFW_TCDISTRIBUTION_TCPACKETCHECKIF_H_

-#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>

-class SpacePacketBase;
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
+class SpacePacketReader;

 /**
 * This interface is used by PacketCheckers for PUS packets and CFDP packets .
 * @ingroup tc_distribution
 */
-class TcPacketCheckIF {
+class CcsdsPacketCheckIF {
 public:
  /**
   * The empty virtual destructor.
   */
-  virtual ~TcPacketCheckIF() {}
+  virtual ~CcsdsPacketCheckIF() = default;

  /**
   * This is the actual method to formally check a certain Packet.
   * The packet's Application Data can not be checked here.
   * @param current_packet The packet to check
   * @return	- @c RETURN_OK on success.
-   * 			- @c INCORRECT_CHECKSUM if checksum is invalid.
-   * 			- @c ILLEGAL_APID if APID does not match.
+   *            - @c INCORRECT_CHECKSUM if checksum is invalid.
+   * 		- @c ILLEGAL_APID if APID does not match.
   */
-  virtual ReturnValue_t checkPacket(SpacePacketBase* currentPacket) = 0;
+  virtual ReturnValue_t checkPacket(const SpacePacketReader& currentPacket, size_t packetLen) = 0;
 };

 #endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKIF_H_ */
--- a/src/fsfw/tcdistribution/CcsdsPacketChecker.cpp
+++ b/src/fsfw/tcdistribution/CcsdsPacketChecker.cpp
@ -0,0 +1,33 @@
+#include "CcsdsPacketChecker.h"
+
+#include "fsfw/tcdistribution/definitions.h"
+#include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
+
+CcsdsPacketChecker::CcsdsPacketChecker(ccsds::PacketType packetType_, uint8_t ccsdsVersion_)
+    : packetType(packetType_), ccsdsVersion(ccsdsVersion_) {}
+
+ReturnValue_t CcsdsPacketChecker::checkPacket(const SpacePacketReader& currentPacket,
+                                              size_t packetLen) {
+  if (checkApid) {
+    if (currentPacket.getApid() != apid) {
+      return tcdistrib::INVALID_APID;
+    }
+  }
+
+  if (currentPacket.getVersion() != ccsdsVersion) {
+    return tcdistrib::INVALID_CCSDS_VERSION;
+  }
+  if (currentPacket.getPacketType() != packetType) {
+    return tcdistrib::INVALID_PACKET_TYPE;
+  }
+  // This assumes that the getFullPacketLen version uses the space packet data length field
+  if (currentPacket.getFullPacketLen() != packetLen) {
+    return tcdistrib::INCOMPLETE_PACKET;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+void CcsdsPacketChecker::setApidToCheck(uint16_t apid_) {
+  apid = apid_;
+  checkApid = true;
+}
--- a/src/fsfw/tcdistribution/CcsdsPacketChecker.h
+++ b/src/fsfw/tcdistribution/CcsdsPacketChecker.h
@ -0,0 +1,20 @@
+#ifndef FSFW_TESTS_CCSDSPACKETCHECKERBASE_H
+#define FSFW_TESTS_CCSDSPACKETCHECKERBASE_H
+
+#include "CcsdsPacketCheckIF.h"
+#include "fsfw/tmtcpacket/ccsds/SpacePacketIF.h"
+
+class CcsdsPacketChecker : public CcsdsPacketCheckIF, public HasReturnvaluesIF {
+ public:
+  CcsdsPacketChecker(ccsds::PacketType packetType, uint8_t ccsdsVersion = 0b000);
+
+  void setApidToCheck(uint16_t apid);
+  ReturnValue_t checkPacket(const SpacePacketReader& currentPacket, size_t packetLen) override;
+
+ protected:
+  bool checkApid = false;
+  uint16_t apid = 0;
+  ccsds::PacketType packetType;
+  uint8_t ccsdsVersion;
+};
+#endif  // FSFW_TESTS_CCSDSPACKETCHECKERBASE_H
--- a/src/fsfw/tcdistribution/CfdpPacketChecker.h
+++ b/src/fsfw/tcdistribution/CfdpPacketChecker.h
@ -1,16 +1,16 @@
 #ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKCFDP_H_
 #define FSFW_TCDISTRIBUTION_TCPACKETCHECKCFDP_H_

-#include "TcPacketCheckIF.h"
+#include "CcsdsPacketCheckIF.h"
 #include "fsfw/FSFW.h"

-class CFDPPacketStored;
+class CfdpPacketStored;

 /**
 * This class performs a formal packet check for incoming CFDP Packets.
 * @ingroup tc_distribution
 */
-class TcPacketCheckCFDP : public TcPacketCheckIF, public HasReturnvaluesIF {
+class CfdpPacketChecker : public CcsdsPacketCheckIF, public HasReturnvaluesIF {
 protected:
  /**
   * The packet id each correct packet should have.
@ -23,11 +23,11 @@ class TcPacketCheckCFDP : public TcPacketCheckIF, public HasReturnvaluesIF {
   * The constructor only sets the APID attribute.
   * @param set_apid The APID to set.
   */
-  TcPacketCheckCFDP(uint16_t setApid);
+  explicit CfdpPacketChecker(uint16_t setApid);

-  ReturnValue_t checkPacket(SpacePacketBase* currentPacket) override;
+  ReturnValue_t checkPacket(const SpacePacketReader& currentPacket, size_t packetLen) override;

-  uint16_t getApid() const;
+  [[nodiscard]] uint16_t getApid() const;
 };

 #endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKCFDP_H_ */
--- a/src/fsfw/tcdistribution/PUSDistributor.cpp
+++ b/src/fsfw/tcdistribution/PUSDistributor.cpp
@ -1,146 +0,0 @@
-#include "fsfw/tcdistribution/PUSDistributor.h"
-
-#include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
-#include "fsfw/tcdistribution/CCSDSDistributorIF.h"
-#include "fsfw/tmtcservices/PusVerificationReport.h"
-
-#define PUS_DISTRIBUTOR_DEBUGGING 0
-
-PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
-                               object_id_t setPacketSource)
-    : TcDistributor(setObjectId),
-      checker(setApid),
-      verifyChannel(),
-      tcStatus(RETURN_FAILED),
-      packetSource(setPacketSource) {}
-
-PUSDistributor::~PUSDistributor() = default;
-
-PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
-#if FSFW_CPP_OSTREAM_ENABLED == 1 && PUS_DISTRIBUTOR_DEBUGGING == 1
-    store_address_t storeId = this->currentMessage.getStorageId());
-    sif::debug << "PUSDistributor::handlePacket received: " << storeId.poolIndex << ", "
-               << storeId.packetIndex << std::endl;
-#endif
-    auto queueMapIt = this->queueMap.end();
-    if (this->currentPacket == nullptr) {
-      return queueMapIt;
-    }
-    this->currentPacket->setStoreAddress(this->currentMessage.getStorageId(), currentPacket);
-    if (currentPacket->getWholeData() != nullptr) {
-      tcStatus = checker.checkPacket(currentPacket);
-      if (tcStatus != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_VERBOSE_LEVEL >= 1
-        const char* keyword = "unnamed error";
-        if (tcStatus == TcPacketCheckPUS::INCORRECT_CHECKSUM) {
-          keyword = "checksum";
-        } else if (tcStatus == TcPacketCheckPUS::INCORRECT_PRIMARY_HEADER) {
-          keyword = "incorrect primary header";
-        } else if (tcStatus == TcPacketCheckPUS::ILLEGAL_APID) {
-          keyword = "illegal APID";
-        } else if (tcStatus == TcPacketCheckPUS::INCORRECT_SECONDARY_HEADER) {
-          keyword = "incorrect secondary header";
-        } else if (tcStatus == TcPacketCheckPUS::INCOMPLETE_PACKET) {
-          keyword = "incomplete packet";
-        }
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::warning << "PUSDistributor::handlePacket: Packet format invalid, " << keyword
-                     << " error" << std::endl;
-#else
-        sif::printWarning("PUSDistributor::handlePacket: Packet format invalid, %s error\n",
-                          keyword);
-#endif
-#endif
-      }
-      uint32_t queue_id = currentPacket->getService();
-      queueMapIt = this->queueMap.find(queue_id);
-    } else {
-      tcStatus = PACKET_LOST;
-    }
-
-    if (queueMapIt == this->queueMap.end()) {
-      tcStatus = DESTINATION_NOT_FOUND;
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::debug << "PUSDistributor::handlePacket: Destination not found" << std::endl;
-#else
-      sif::printDebug("PUSDistributor::handlePacket: Destination not found\n");
-#endif /* !FSFW_CPP_OSTREAM_ENABLED == 1 */
-#endif
-    }
-
-    if (tcStatus != RETURN_OK) {
-      return this->queueMap.end();
-    } else {
-      return queueMapIt;
-    }
-}
-
-ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
-  uint16_t serviceId = service->getIdentifier();
-#if PUS_DISTRIBUTOR_DEBUGGING == 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::info << "Service ID: " << static_cast<int>(serviceId) << std::endl;
-#else
-  sif::printInfo("Service ID: %d\n", static_cast<int>(serviceId));
-#endif
-#endif
-  MessageQueueId_t queue = service->getRequestQueue();
-  auto returnPair = queueMap.emplace(serviceId, queue);
-  if (not returnPair.second) {
-#if FSFW_VERBOSE_LEVEL >= 1
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "PUSDistributor::registerService: Service ID already"
-                  " exists in map"
-               << std::endl;
-#else
-    sif::printError("PUSDistributor::registerService: Service ID already exists in map\n");
-#endif
-#endif
-    return SERVICE_ID_ALREADY_EXISTS;
-  }
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-MessageQueueId_t PUSDistributor::getRequestQueue() { return tcQueue->getId(); }
-
-ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
-  if (queueStatus != RETURN_OK) {
-    tcStatus = queueStatus;
-  }
-  if (tcStatus != RETURN_OK) {
-    this->verifyChannel.sendFailureReport(tc_verification::ACCEPTANCE_FAILURE, currentPacket,
-                                          tcStatus);
-    // A failed packet is deleted immediately after reporting,
-    // otherwise it will block memory.
-    currentPacket->deletePacket();
-    return RETURN_FAILED;
-  } else {
-    this->verifyChannel.sendSuccessReport(tc_verification::ACCEPTANCE_SUCCESS, currentPacket);
-    return RETURN_OK;
-  }
-}
-
-uint16_t PUSDistributor::getIdentifier() { return checker.getApid(); }
-
-ReturnValue_t PUSDistributor::initialize() {
-  currentPacket = new TcPacketStoredPus();
-  if (currentPacket == nullptr) {
-    // Should not happen, memory allocation failed!
-    return ObjectManagerIF::CHILD_INIT_FAILED;
-  }
-
-  auto* ccsdsDistributor = ObjectManager::instance()->get<CCSDSDistributorIF>(packetSource);
-  if (ccsdsDistributor == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "PUSDistributor::initialize: Packet source invalid" << std::endl;
-    sif::error << " Make sure it exists and implements CCSDSDistributorIF!" << std::endl;
-#else
-    sif::printError("PUSDistributor::initialize: Packet source invalid\n");
-    sif::printError("Make sure it exists and implements CCSDSDistributorIF\n");
-#endif
-    return RETURN_FAILED;
-  }
-  return ccsdsDistributor->registerApplication(this);
-}
--- a/src/fsfw/tcdistribution/PusDistributor.cpp
+++ b/src/fsfw/tcdistribution/PusDistributor.cpp
@ -0,0 +1,169 @@
+#include "fsfw/tcdistribution/PusDistributor.h"
+
+#include "definitions.h"
+#include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/tcdistribution/CCSDSDistributorIF.h"
+#include "fsfw/tmtcservices/PusVerificationReport.h"
+
+#define PUS_DISTRIBUTOR_DEBUGGING 0
+
+PusDistributor::PusDistributor(uint16_t setApid, object_id_t setObjectId,
+                               CCSDSDistributorIF* distributor, StorageManagerIF* store_)
+    : TcDistributor(setObjectId),
+      store(store_),
+      checker(setApid, ccsds::PacketType::TC),
+      ccsdsDistributor(distributor),
+      tcStatus(RETURN_FAILED) {}
+
+PusDistributor::~PusDistributor() = default;
+
+PusDistributor::TcMqMapIter PusDistributor::selectDestination() {
+#if FSFW_CPP_OSTREAM_ENABLED == 1 && PUS_DISTRIBUTOR_DEBUGGING == 1
+  store_address_t storeId = currentMessage.getStorageId();
+  sif::debug << "PUSDistributor::handlePacket received: " << storeId.poolIndex << ", "
+             << storeId.packetIndex << std::endl;
+#endif
+  auto queueMapIt = queueMap.end();
+  // TODO: Need to set the data
+  const uint8_t* packetPtr = nullptr;
+  size_t packetLen = 0;
+  if (store->getData(currentMessage.getStorageId(), &packetPtr, &packetLen) !=
+      HasReturnvaluesIF::RETURN_OK) {
+    return queueMapIt;
+  }
+  ReturnValue_t result = reader.setReadOnlyData(packetPtr, packetLen);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    tcStatus = PACKET_LOST;
+    return queueMapIt;
+  }
+  // CRC check done by checker
+  result = reader.parseDataWithoutCrcCheck();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    tcStatus = PACKET_LOST;
+    return queueMapIt;
+  }
+  if (reader.getFullData() != nullptr) {
+    tcStatus = checker.checkPacket(reader, reader.getFullPacketLen());
+    if (tcStatus != HasReturnvaluesIF::RETURN_OK) {
+      checkerFailurePrinter();
+    }
+    uint32_t queue_id = reader.getService();
+    queueMapIt = queueMap.find(queue_id);
+  } else {
+    tcStatus = PACKET_LOST;
+  }
+
+  if (queueMapIt == this->queueMap.end()) {
+    tcStatus = DESTINATION_NOT_FOUND;
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::debug << "PUSDistributor::handlePacket: Destination not found" << std::endl;
+#else
+    sif::printDebug("PUSDistributor::handlePacket: Destination not found\n");
+#endif /* !FSFW_CPP_OSTREAM_ENABLED == 1 */
+#endif
+  }
+
+  if (tcStatus != RETURN_OK) {
+    return this->queueMap.end();
+  } else {
+    return queueMapIt;
+  }
+}
+
+ReturnValue_t PusDistributor::registerService(AcceptsTelecommandsIF* service) {
+  uint16_t serviceId = service->getIdentifier();
+#if PUS_DISTRIBUTOR_DEBUGGING == 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::info << "Service ID: " << static_cast<int>(serviceId) << std::endl;
+#else
+  sif::printInfo("Service ID: %d\n", static_cast<int>(serviceId));
+#endif
+#endif
+  MessageQueueId_t queue = service->getRequestQueue();
+  auto returnPair = queueMap.emplace(serviceId, queue);
+  if (not returnPair.second) {
+#if FSFW_VERBOSE_LEVEL >= 1
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "PUSDistributor::registerService: Service ID already"
+                  " exists in map"
+               << std::endl;
+#else
+    sif::printError("PUSDistributor::registerService: Service ID already exists in map\n");
+#endif
+#endif
+    return SERVICE_ID_ALREADY_EXISTS;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t PusDistributor::getRequestQueue() { return tcQueue->getId(); }
+
+ReturnValue_t PusDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+  if (queueStatus != RETURN_OK) {
+    tcStatus = queueStatus;
+  }
+  if (tcStatus != RETURN_OK) {
+    verifyChannel->sendFailureReport(
+        VerifFailureParams(tcverif::ACCEPTANCE_FAILURE, reader, tcStatus));
+    // A failed packet is deleted immediately after reporting,
+    // otherwise it will block memory.
+    store->deleteData(currentMessage.getStorageId());
+    return RETURN_FAILED;
+  } else {
+    verifyChannel->sendSuccessReport(VerifSuccessParams(tcverif::ACCEPTANCE_SUCCESS, reader));
+    return RETURN_OK;
+  }
+}
+
+uint16_t PusDistributor::getIdentifier() { return checker.getApid(); }
+
+ReturnValue_t PusDistributor::initialize() {
+  if (store == nullptr) {
+    store = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
+    if (store == nullptr) {
+      return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
+  }
+  if (ccsdsDistributor == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "PUSDistributor::initialize: Packet source invalid" << std::endl;
+    sif::error << " Make sure it exists and implements CCSDSDistributorIF!" << std::endl;
+#else
+    sif::printError("PusDistributor::initialize: Packet source invalid\n");
+    sif::printError("Make sure it exists and implements CCSDSDistributorIF\n");
+#endif
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+  if (verifyChannel == nullptr) {
+    verifyChannel = ObjectManager::instance()->get<VerificationReporterIF>(objects::TC_VERIFICATOR);
+    if (verifyChannel == nullptr) {
+      return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
+  }
+  return ccsdsDistributor->registerApplication(this);
+}
+
+void PusDistributor::checkerFailurePrinter() const {
+#if FSFW_VERBOSE_LEVEL >= 1
+  const char* keyword = "unnamed error";
+  if (tcStatus == tcdistrib::INCORRECT_CHECKSUM) {
+    keyword = "checksum";
+  } else if (tcStatus == tcdistrib::INCORRECT_PRIMARY_HEADER) {
+    keyword = "incorrect primary header";
+  } else if (tcStatus == tcdistrib::INVALID_APID) {
+    keyword = "illegal APID";
+  } else if (tcStatus == tcdistrib::INCORRECT_SECONDARY_HEADER) {
+    keyword = "incorrect secondary header";
+  } else if (tcStatus == tcdistrib::INCOMPLETE_PACKET) {
+    keyword = "incomplete packet";
+  }
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  sif::warning << "PUSDistributor::handlePacket: Packet format invalid, " << keyword << " error"
+               << std::endl;
+#else
+  sif::printWarning("PUSDistributor::handlePacket: Packet format invalid, %s error\n", keyword);
+#endif
+#endif
+}
--- a/src/fsfw/tcdistribution/PusDistributor.h
+++ b/src/fsfw/tcdistribution/PusDistributor.h
@ -2,20 +2,22 @@
 #define FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_

 #include "PUSDistributorIF.h"
+#include "PusPacketChecker.h"
 #include "TcDistributor.h"
-#include "TcPacketCheckPUS.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "fsfw/tmtcpacket/pus/tc.h"
 #include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
 #include "fsfw/tmtcservices/VerificationReporter.h"

+class CCSDSDistributorIF;
+
 /**
 * This class accepts PUS Telecommands and forwards them to Application
 * services. In addition, the class performs a formal packet check and
 * sends acceptance success or failure messages.
 * @ingroup tc_distribution
 */
-class PUSDistributor : public TcDistributor, public PUSDistributorIF, public AcceptsTelecommandsIF {
+class PusDistributor : public TcDistributor, public PUSDistributorIF, public AcceptsTelecommandsIF {
 public:
  /**
   * The ctor passes @c set_apid to the checker class and calls the
@ -25,30 +27,31 @@ class PUSDistributor : public TcDistributor, public PUSDistributorIF, public Acc
   * @param setPacketSource Object ID of the source of TC packets.
   * Must implement CCSDSDistributorIF.
   */
-  PUSDistributor(uint16_t setApid, object_id_t setObjectId, object_id_t setPacketSource);
+  PusDistributor(uint16_t setApid, object_id_t setObjectId, CCSDSDistributorIF* packetSource,
+                 StorageManagerIF* store = nullptr);
  /**
   * The destructor is empty.
   */
-  virtual ~PUSDistributor();
+  ~PusDistributor() override;
  ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
  MessageQueueId_t getRequestQueue() override;
  ReturnValue_t initialize() override;
  uint16_t getIdentifier() override;

 protected:
+  StorageManagerIF* store;
  /**
   * This attribute contains the class, that performs a formal packet check.
   */
-  TcPacketCheckPUS checker;
+  PusPacketChecker checker;
  /**
   * With this class, verification messages are sent to the
   * TC Verification service.
   */
-  VerificationReporter verifyChannel;
-  /**
-   * The currently handled packet is stored here.
-   */
-  TcPacketStoredPus* currentPacket = nullptr;
+  VerificationReporterIF* verifyChannel = nullptr;
+  //! Cached for initialization
+  CCSDSDistributorIF* ccsdsDistributor = nullptr;
+  PusTcReader reader;

  /**
   * With this variable, the current check status is stored to generate
@ -56,8 +59,6 @@ class PUSDistributor : public TcDistributor, public PUSDistributorIF, public Acc
   */
  ReturnValue_t tcStatus;

-  const object_id_t packetSource;
-
  /**
   * This method reads the packet service, checks if such a service is
   * registered and forwards the packet to the destination.
@ -72,6 +73,8 @@ class PUSDistributor : public TcDistributor, public PUSDistributorIF, public Acc
   * success/failure messages.
   */
  ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus) override;
+
+  void checkerFailurePrinter() const;
 };

 #endif /* FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */
--- a/src/fsfw/tcdistribution/PusPacketChecker.cpp
+++ b/src/fsfw/tcdistribution/PusPacketChecker.cpp
@ -0,0 +1,30 @@
+#include "fsfw/tcdistribution/PusPacketChecker.h"
+
+#include "fsfw/globalfunctions/CRC.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/tcdistribution/definitions.h"
+#include "fsfw/tmtcpacket/pus/tc/PusTcReader.h"
+
+PusPacketChecker::PusPacketChecker(uint16_t apid, ccsds::PacketType packetType_,
+                                   ecss::PusVersion pusVersion_)
+    : pusVersion(pusVersion_), apid(apid) {}
+
+ReturnValue_t PusPacketChecker::checkPacket(const PusTcReader& pusPacket, size_t packetLen) {
+  // Other primary header fields are checked by base class
+  if (not pusPacket.hasSecHeader()) {
+    return tcdistrib::INVALID_SEC_HEADER_FIELD;
+  }
+  uint16_t calculated_crc = CRC::crc16ccitt(pusPacket.getFullData(), pusPacket.getFullPacketLen());
+  if (calculated_crc != 0) {
+    return tcdistrib::INCORRECT_CHECKSUM;
+  }
+  if (pusPacket.getApid() != apid) {
+    return tcdistrib::INVALID_APID;
+  }
+  if (pusPacket.getPusVersion() != pusVersion) {
+    return tcdistrib::INVALID_PUS_VERSION;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint16_t PusPacketChecker::getApid() const { return apid; }
--- a/src/fsfw/tcdistribution/PusPacketChecker.h
+++ b/src/fsfw/tcdistribution/PusPacketChecker.h
@ -0,0 +1,34 @@
+#ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_
+#define FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_
+
+#include "fsfw/FSFW.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/tmtcpacket/pus/defs.h"
+#include "fsfw/tmtcservices/PusVerificationReport.h"
+
+/**
+ * This class performs a formal packet check for incoming PUS Telecommand Packets.
+ * Currently, it only checks if the APID and CRC are correct.
+ * @ingroup tc_distribution
+ */
+class PusPacketChecker {
+ public:
+  /**
+   * The constructor only sets the APID attribute.
+   * @param set_apid The APID to set.
+   */
+  explicit PusPacketChecker(uint16_t apid, ccsds::PacketType packetType,
+                            ecss::PusVersion = ecss::PusVersion::PUS_C);
+
+  ReturnValue_t checkPacket(const PusTcReader& currentPacket, size_t packetLen);
+
+  [[nodiscard]] uint16_t getApid() const;
+
+ protected:
+  ecss::PusVersion pusVersion;
+  uint16_t apid;
+
+ private:
+};
+
+#endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_ */
--- a/src/fsfw/tcdistribution/TcDistributor.cpp
+++ b/src/fsfw/tcdistribution/TcDistributor.cpp
@ -13,25 +13,24 @@ TcDistributor::TcDistributor(object_id_t objectId) : SystemObject(objectId) {
 TcDistributor::~TcDistributor() { QueueFactory::instance()->deleteMessageQueue(tcQueue); }

 ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
-  ReturnValue_t status = RETURN_OK;
+  ReturnValue_t status;
  for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
       status = tcQueue->receiveMessage(&currentMessage)) {
    status = handlePacket();
  }
  if (status == MessageQueueIF::EMPTY) {
    return RETURN_OK;
-  } else {
-    return status;
  }
+  return status;
 }

 ReturnValue_t TcDistributor::handlePacket() {
-  TcMqMapIter queueMapIt = this->selectDestination();
-  ReturnValue_t returnValue = RETURN_FAILED;
-  if (queueMapIt != this->queueMap.end()) {
-    returnValue = this->tcQueue->sendMessage(queueMapIt->second, &this->currentMessage);
+  auto queueMapIt = selectDestination();
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
+  if (queueMapIt != queueMap.end()) {
+    result = tcQueue->sendMessage(queueMapIt->second, &currentMessage);
  }
-  return this->callbackAfterSending(returnValue);
+  return callbackAfterSending(result);
 }

 void TcDistributor::print() {
--- a/src/fsfw/tcdistribution/TcPacketCheckCFDP.cpp
+++ b/src/fsfw/tcdistribution/TcPacketCheckCFDP.cpp
@ -1,9 +1,11 @@
-#include "fsfw/tcdistribution/TcPacketCheckCFDP.h"
+#include "fsfw/tcdistribution/CfdpPacketChecker.h"
+#include "fsfw/tmtcpacket/cfdp/CfdpPacketStored.h"

-#include "fsfw/tmtcpacket/cfdp/CFDPPacketStored.h"
+CfdpPacketChecker::CfdpPacketChecker(uint16_t setApid) : apid(setApid) {}

-TcPacketCheckCFDP::TcPacketCheckCFDP(uint16_t setApid) : apid(setApid) {}
+ReturnValue_t CfdpPacketChecker::checkPacket(const SpacePacketReader& currentPacket,
+                                             size_t packetLen) {
+  return RETURN_OK;
+}

-ReturnValue_t TcPacketCheckCFDP::checkPacket(SpacePacketBase* currentPacket) { return RETURN_OK; }
-
-uint16_t TcPacketCheckCFDP::getApid() const { return apid; }
+uint16_t CfdpPacketChecker::getApid() const { return apid; }
--- a/src/fsfw/tcdistribution/TcPacketCheckPUS.cpp
+++ b/src/fsfw/tcdistribution/TcPacketCheckPUS.cpp
@ -1,44 +0,0 @@
-#include "fsfw/tcdistribution/TcPacketCheckPUS.h"
-
-#include "fsfw/globalfunctions/CRC.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
-#include "fsfw/storagemanager/StorageManagerIF.h"
-#include "fsfw/tmtcpacket/pus/tc/TcPacketPusBase.h"
-#include "fsfw/tmtcpacket/pus/tc/TcPacketStoredBase.h"
-#include "fsfw/tmtcpacket/pus/tc/TcPacketStoredPus.h"
-#include "fsfw/tmtcservices/VerificationCodes.h"
-
-TcPacketCheckPUS::TcPacketCheckPUS(uint16_t setApid) : apid(setApid) {}
-
-ReturnValue_t TcPacketCheckPUS::checkPacket(SpacePacketBase* currentPacket) {
-  TcPacketStoredBase* storedPacket = dynamic_cast<TcPacketStoredBase*>(currentPacket);
-  TcPacketPusBase* tcPacketBase = dynamic_cast<TcPacketPusBase*>(currentPacket);
-  if (tcPacketBase == nullptr or storedPacket == nullptr) {
-    return RETURN_FAILED;
-  }
-  uint16_t calculated_crc =
-      CRC::crc16ccitt(tcPacketBase->getWholeData(), tcPacketBase->getFullSize());
-  if (calculated_crc != 0) {
-    return INCORRECT_CHECKSUM;
-  }
-  bool condition = (not tcPacketBase->hasSecondaryHeader()) or
-                   (tcPacketBase->getPacketVersionNumber() != CCSDS_VERSION_NUMBER) or
-                   (not tcPacketBase->isTelecommand());
-  if (condition) {
-    return INCORRECT_PRIMARY_HEADER;
-  }
-  if (tcPacketBase->getAPID() != this->apid) return ILLEGAL_APID;
-
-  if (not storedPacket->isSizeCorrect()) {
-    return INCOMPLETE_PACKET;
-  }
-
-  condition = (tcPacketBase->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
-              (tcPacketBase->getPusVersionNumber() != PUS_VERSION_NUMBER);
-  if (condition) {
-    return INCORRECT_SECONDARY_HEADER;
-  }
-  return RETURN_OK;
-}
-
-uint16_t TcPacketCheckPUS::getApid() const { return apid; }
--- a/src/fsfw/tcdistribution/TcPacketCheckPUS.h
+++ b/src/fsfw/tcdistribution/TcPacketCheckPUS.h
@ -1,61 +0,0 @@
-#ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_
-#define FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_
-
-#include "TcPacketCheckIF.h"
-#include "fsfw/FSFW.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
-#include "fsfw/tmtcservices/PusVerificationReport.h"
-
-class TcPacketStoredBase;
-
-/**
- * This class performs a formal packet check for incoming PUS Telecommand Packets.
- * Currently, it only checks if the APID and CRC are correct.
- * @ingroup tc_distribution
- */
-class TcPacketCheckPUS : public TcPacketCheckIF, public HasReturnvaluesIF {
- protected:
-  /**
-   * Describes the version number a packet must have to pass.
-   */
-  static constexpr uint8_t CCSDS_VERSION_NUMBER = 0;
-  /**
-   * Describes the secondary header a packet must have to pass.
-   */
-  static constexpr uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
-  /**
-   * Describes the TC Packet PUS Version Number a packet must have to pass.
-   */
-#if FSFW_USE_PUS_C_TELECOMMANDS == 1
-  static constexpr uint8_t PUS_VERSION_NUMBER = 2;
-#else
-  static constexpr uint8_t PUS_VERSION_NUMBER = 1;
-#endif
-
-  /**
-   * The packet id each correct packet should have.
-   * It is composed of the APID and some static fields.
-   */
-  uint16_t apid;
-
- public:
-  static const uint8_t INTERFACE_ID = CLASS_ID::TC_PACKET_CHECK;
-  static const ReturnValue_t ILLEGAL_APID = MAKE_RETURN_CODE(0);
-  static const ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE(1);
-  static const ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE(2);
-  static const ReturnValue_t ILLEGAL_PACKET_TYPE = MAKE_RETURN_CODE(3);
-  static const ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE(4);
-  static const ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE(5);
-  static const ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE(6);
-  /**
-   * The constructor only sets the APID attribute.
-   * @param set_apid The APID to set.
-   */
-  TcPacketCheckPUS(uint16_t setApid);
-
-  ReturnValue_t checkPacket(SpacePacketBase* currentPacket) override;
-
-  uint16_t getApid() const;
-};
-
-#endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_ */
--- a/src/fsfw/tcdistribution/definitions.h
+++ b/src/fsfw/tcdistribution/definitions.h
@ -0,0 +1,24 @@
+#ifndef FSFW_TMTCPACKET_DEFINITIONS_H
+#define FSFW_TMTCPACKET_DEFINITIONS_H
+
+#include <cstdint>
+
+#include "fsfw/returnvalues/FwClassIds.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
+namespace tcdistrib {
+static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_CHECK;
+static constexpr ReturnValue_t INVALID_CCSDS_VERSION = MAKE_RETURN_CODE(0);
+static constexpr ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(1);
+static constexpr ReturnValue_t INVALID_PACKET_TYPE = MAKE_RETURN_CODE(2);
+static constexpr ReturnValue_t INVALID_SEC_HEADER_FIELD = MAKE_RETURN_CODE(3);
+static constexpr ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE(4);
+
+static constexpr ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE(5);
+static constexpr ReturnValue_t INVALID_PUS_VERSION = MAKE_RETURN_CODE(6);
+static constexpr ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE(7);
+static constexpr ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE(8);
+static constexpr ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE(9);
+
+};      // namespace tcdistrib
+#endif  // FSFW_TMTCPACKET_DEFINITIONS_H
--- a/src/fsfw/timemanager/CCSDSTime.cpp
+++ b/src/fsfw/timemanager/CCSDSTime.cpp
@ -504,7 +504,7 @@ ReturnValue_t CCSDSTime::convertFromCDS(timeval* to, const uint8_t* from, size_t
  } else if ((pField & 0b11) == 0b10) {
    expectedLength += 4;
  }
-  if (foundLength != NULL) {
+  if (foundLength != nullptr) {
    *foundLength = expectedLength;
  }
  if (expectedLength > maxLength) {
--- a/src/fsfw/timemanager/CCSDSTime.h
+++ b/src/fsfw/timemanager/CCSDSTime.h
@ -6,9 +6,9 @@
 #include <cstddef>
 #include <cstdint>

-#include "../returnvalues/HasReturnvaluesIF.h"
 #include "Clock.h"
 #include "clockDefinitions.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"

 bool operator<(const timeval &lhs, const timeval &rhs);
 bool operator<=(const timeval &lhs, const timeval &rhs);
--- a/src/fsfw/timemanager/CMakeLists.txt
+++ b/src/fsfw/timemanager/CMakeLists.txt
@ -1,3 +1,4 @@
 target_sources(
-  ${LIB_FSFW_NAME} PRIVATE CCSDSTime.cpp Countdown.cpp Stopwatch.cpp
-                           TimeMessage.cpp TimeStamper.cpp ClockCommon.cpp)
+  ${LIB_FSFW_NAME}
+  PRIVATE CCSDSTime.cpp Countdown.cpp Stopwatch.cpp TimeMessage.cpp
+          CdsShortTimeStamper.cpp ClockCommon.cpp)
--- a/src/fsfw/timemanager/CcsdsTimeStampReader.cpp
+++ b/src/fsfw/timemanager/CcsdsTimeStampReader.cpp
@ -0,0 +1,14 @@
+#include "CcsdsTimeStampReader.h"
+
+#include "CCSDSTime.h"
+
+ReturnValue_t CcsdsTimestampReader::readTimeStamp(const uint8_t* buffer, uint8_t maxSize) {
+  ReturnValue_t result = CCSDSTime::convertFromCcsds(&time, buffer, &timestampLen, maxSize);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  return result;
+}
+
+timeval& CcsdsTimestampReader::getTime() { return time; }
+size_t CcsdsTimestampReader::getTimestampLen() { return timestampLen; }
--- a/src/fsfw/timemanager/CcsdsTimeStampReader.h
+++ b/src/fsfw/timemanager/CcsdsTimeStampReader.h
@ -0,0 +1,17 @@
+#ifndef FSFW_TIMEMANAGER_CCSDSTIMESTAMPREADER_H
+#define FSFW_TIMEMANAGER_CCSDSTIMESTAMPREADER_H
+
+#include <cstdlib>
+
+#include "TimeReaderIF.h"
+
+class CcsdsTimestampReader : public TimeReaderIF {
+ public:
+  timeval& getTime() override;
+
+ private:
+  timeval time{};
+  size_t timestampLen = 0;
+};
+
+#endif  // FSFW_TIMEMANAGER_CCSDSTIMESTAMPREADER_H
--- a/src/fsfw/timemanager/CdsShortTimeStamper.cpp
+++ b/src/fsfw/timemanager/CdsShortTimeStamper.cpp
@ -0,0 +1,49 @@
+#include "fsfw/timemanager/CdsShortTimeStamper.h"
+
+#include <cstring>
+
+#include "fsfw/timemanager/Clock.h"
+
+CdsShortTimeStamper::CdsShortTimeStamper(object_id_t objectId) : SystemObject(objectId) {}
+
+ReturnValue_t CdsShortTimeStamper::addTimeStamp(uint8_t *buffer, const uint8_t maxSize) {
+  size_t serLen = 0;
+  return serialize(&buffer, &serLen, maxSize, SerializeIF::Endianness::NETWORK);
+}
+
+ReturnValue_t CdsShortTimeStamper::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                             SerializeIF::Endianness streamEndianness) const {
+  if (*size + getSerializedSize() > maxSize) {
+    return SerializeIF::BUFFER_TOO_SHORT;
+  }
+  timeval now{};
+  Clock::getClock_timeval(&now);
+  CCSDSTime::CDS_short cds{};
+  ReturnValue_t result = CCSDSTime::convertToCcsds(&cds, &now);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  std::memcpy(*buffer, &cds, sizeof(cds));
+  *buffer += getSerializedSize();
+  *size += getSerializedSize();
+  return result;
+}
+
+size_t CdsShortTimeStamper::getSerializedSize() const { return getTimestampSize(); }
+
+ReturnValue_t CdsShortTimeStamper::deSerialize(const uint8_t **buffer, size_t *size,
+                                               SerializeIF::Endianness streamEndianness) {
+  return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+ReturnValue_t CdsShortTimeStamper::readTimeStamp(const uint8_t *buffer, size_t maxSize) {
+  if (maxSize < getTimestampSize()) {
+    return SerializeIF::STREAM_TOO_SHORT;
+  }
+  size_t foundLen = 0;
+  return CCSDSTime::convertFromCcsds(&readTime, buffer, &foundLen, maxSize);
+}
+
+timeval &CdsShortTimeStamper::getTime() { return readTime; }
+
+size_t CdsShortTimeStamper::getTimestampSize() const { return TIMESTAMP_LEN; }
--- a/src/fsfw/timemanager/CdsShortTimeStamper.h
+++ b/src/fsfw/timemanager/CdsShortTimeStamper.h
@ -1,9 +1,10 @@
 #ifndef FSFW_TIMEMANAGER_TIMESTAMPER_H_
 #define FSFW_TIMEMANAGER_TIMESTAMPER_H_

-#include "../objectmanager/SystemObject.h"
 #include "CCSDSTime.h"
+#include "TimeReaderIF.h"
 #include "TimeStamperIF.h"
+#include "fsfw/objectmanager/SystemObject.h"

 /**
 * @brief   Time stamper which can be used to add any timestamp to a
@ -14,14 +15,15 @@
 * overriding the #addTimeStamp function.
 * @ingroup utility
 */
-class TimeStamper : public TimeStamperIF, public SystemObject {
+class CdsShortTimeStamper : public TimeStamperIF, public TimeReaderIF, public SystemObject {
 public:
+  static constexpr size_t TIMESTAMP_LEN = 7;
  /**
   * @brief   Default constructor which also registers the time stamper as a
   *          system object so it can be found with the #objectManager.
   * @param objectId
   */
-  TimeStamper(object_id_t objectId);
+  explicit CdsShortTimeStamper(object_id_t objectId);

  /**
   * Adds a CCSDS CDC short 8 byte timestamp to the given buffer.
@ -30,7 +32,18 @@ class TimeStamper : public TimeStamperIF, public SystemObject {
   * @param maxSize
   * @return
   */
-  virtual ReturnValue_t addTimeStamp(uint8_t* buffer, const uint8_t maxSize);
+  ReturnValue_t addTimeStamp(uint8_t *buffer, uint8_t maxSize) override;
+  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                          Endianness streamEndianness) const override;
+  [[nodiscard]] size_t getSerializedSize() const override;
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                            Endianness streamEndianness) override;
+  ReturnValue_t readTimeStamp(const uint8_t *buffer, size_t maxSize) override;
+  timeval &getTime() override;
+  [[nodiscard]] size_t getTimestampSize() const override;
+
+ private:
+  timeval readTime{};
 };

 #endif /* FSFW_TIMEMANAGER_TIMESTAMPER_H_ */
--- a/src/fsfw/timemanager/Clock.h
+++ b/src/fsfw/timemanager/Clock.h
@ -11,7 +11,7 @@
 #ifdef WIN32
 #include <winsock2.h>
 #else
-#include <sys/time.h>
+#include <ctime>
 #endif

 class Clock {
@ -33,7 +33,7 @@ class Clock {
   *
   * @deprecated, we should not worry about ticks, but only time
   */
-  static uint32_t getTicksPerSecond(void);
+  static uint32_t getTicksPerSecond();
  /**
   * This system call sets the system time.
   * To set the time, it uses a TimeOfDay_t struct.
@ -148,7 +148,7 @@ class Clock {
   * @return
   *  - @c RETURN_OK on success.
   */
-  static ReturnValue_t setLeapSeconds(const uint16_t leapSeconds_);
+  static ReturnValue_t setLeapSeconds(uint16_t leapSeconds_);

  /**
   * Get the Leap Seconds since 1972
--- a/src/fsfw/timemanager/ReceivesTimeInfoIF.h
+++ b/src/fsfw/timemanager/ReceivesTimeInfoIF.h
@ -1,7 +1,7 @@
 #ifndef FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_
 #define FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_

-#include "../ipc/MessageQueueSenderIF.h"
+#include "fsfw/ipc/MessageQueueSenderIF.h"

 /**
 * This is a Interface for classes that receive timing information
@ -13,11 +13,11 @@ class ReceivesTimeInfoIF {
   * Returns the id of the queue which receives the timing information.
   * @return Queue id of the timing queue.
   */
-  virtual MessageQueueId_t getTimeReceptionQueue() const = 0;
+  [[nodiscard]] virtual MessageQueueId_t getTimeReceptionQueue() const = 0;
  /**
   * Empty virtual destructor.
   */
-  virtual ~ReceivesTimeInfoIF() {}
+  virtual ~ReceivesTimeInfoIF() = default;
 };

 #endif /* FSFW_TIMEMANAGER_RECEIVESTIMEINFOIF_H_ */
--- a/src/fsfw/timemanager/TimeMessage.h
+++ b/src/fsfw/timemanager/TimeMessage.h
@ -3,8 +3,8 @@

 #include <cstring>

-#include "../ipc/MessageQueueMessage.h"
 #include "Clock.h"
+#include "fsfw/ipc/MessageQueueMessage.h"

 class TimeMessage : public MessageQueueMessage {
 protected:
--- a/Show More
+++ b/Show More