Update and clean up HK and Local Pool Modules

2024-12-12 16:15:31 +01:00
64 changed files with 151 additions and 516 deletions
@@ -26,8 +26,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).

 ## Added

- functions to configure pus routing
- FreeRTOS monotonic clock which is not subjected to time jumps of the system clock
 - add CFDP subsystem ID
  https://egit.irs.uni-stuttgart.de/fsfw/fsfw/pulls/742
 - `PusTmZcWriter` now exposes API to set message counter field.
@@ -36,21 +34,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).

 ## Changed

- send HK one-parameter-report back to sender instead of default hk queue
- Complete overhaul of HK subsystem. Replaced local data pool manager by periodic HK
+- Complete refactoring of HK subsystem. Replaced local data pool manager by periodic HK
  helper. The shared pool and the periodic HK generation are now distinct concepts.
- The local HK manager was replaced by a periodic HK helper which has reduced responsibilities.
-  It takes care of tracking the HK generation using a set specification provided by the user.n
-  However, it leaves serialization of the HK data completely to the developer. This removes a major
-  constraint on the format of the HK data, which was previously constrained to implementors of a
-  certain base class.
- The former set classes and pool objects are still available for HK set specification and
-  generation. The API has changed, but the general usage and their architecture has not.
- A new set of set classes and helper objects to specify HK sets and data which does not need to be
-  shared was added as well. The majority of datasets do not need to be shared anyway.
- The non-shared API retain the capability of appending of a validity blob for each piece of set
-  data at the end of the HK data. For both non-shared and shared data, this capability can be
-  specified in the constructor, and defaults to true.
 - Improved File System Abstraction to be more in line with normal filesystems.
 - CFDP implementation was improved, has now even less dependencies on other FSFW components
  and allows one inserted packet per state machine call.
@@ -70,8 +55,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
  configurable.
 - Switched to vendored versions for both the Embedded Template Library (ETL) and the
  Catch2 unittesting library.
- Increased maximum number of mode tables from 70 to 100
- Exposed health table mutex via getter function
+
 ## Added

 - `EventManager`: Add function to print all listeners.
@@ -142,7 +142,7 @@ if(FSFW_BUILD_TESTS)
  configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h)

  project(${FSFW_TEST_TGT} CXX C)
-  add_executable(${FSFW_TEST_TGT})
+  add_executable(${FSFW_TEST_TGT} unittests/datapool/testDataset.cpp)
  if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
    set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION
                                                  TRUE)
@@ -18,13 +18,13 @@ class MgmRM3100Handler : public DeviceHandlerBase {
  static const uint8_t INTERFACE_ID = CLASS_ID::MGM_RM3100;

  //! [EXPORT] : [COMMENT] P1: TMRC value which was set, P2: 0
-  static constexpr Event tmrcSet = event::makeEvent<SUBSYSTEM_ID::MGM_RM3100, 0x00, severity::INFO>();
+  static constexpr Event tmrcSet = event::makeEvent(SUBSYSTEM_ID::MGM_RM3100, 0x00, severity::INFO);

  //! [EXPORT] : [COMMENT] Cycle counter set. P1: First two bytes new Cycle Count X
  //! P1: Second two bytes new Cycle Count Y
  //! P2: New cycle count Z
  static constexpr Event cycleCountersSet =
-      event::makeEvent<SUBSYSTEM_ID::MGM_RM3100, 0x01, severity::INFO>();
+      event::makeEvent(SUBSYSTEM_ID::MGM_RM3100, 0x01, severity::INFO);

  MgmRM3100Handler(object_id_t objectId, object_id_t deviceCommunication, CookieIF *comCookie,
                   uint32_t transitionDelay);
@@ -71,7 +71,6 @@ static constexpr size_t FSFW_EVENTMGMR_RANGEMATCHERS   = 120;
 static constexpr uint8_t FSFW_CSB_FIFO_DEPTH = 6;

 static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 124;
-static constexpr size_t FSFW_PRINT_BUFFER_AMOUNT = 32;

 static constexpr size_t FSFW_MAX_TM_PACKET_SIZE = 2048;

@@ -18,12 +18,12 @@ else
  echo "No ${cmake_fmt} tool found, not formatting CMake files"
 fi

-cpp_format="clang-format-19"
+cpp_format="clang-format"
 file_selectors="-iname *.h -o -iname *.cpp -o -iname *.c -o -iname *.tpp"
 if command -v ${cpp_format} &> /dev/null; then
  for dir in ${folder_list[@]}; do
    echo "Auto-formatting ${dir} recursively"
-    find ${dir} ${file_selectors} | xargs ${cpp_format} --style=file -i
+    find ${dir} ${file_selectors} | xargs clang-format --style=file -i
  done
 else
  echo "No ${cpp_format} tool found, not formatting C++/C files"
@@ -9,9 +9,7 @@
 #include "fsfw/cfdp/pdu/FileDataReader.h"
 #include "fsfw/cfdp/pdu/FinishedPduCreator.h"
 #include "fsfw/cfdp/pdu/HeaderReader.h"
-#include "fsfw/cfdp/pdu/KeepAlivePduCreator.h"
 #include "fsfw/objectmanager.h"
-#include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tmtcservices/TmTcMessage.h"

 using namespace returnvalue;
@@ -452,19 +450,6 @@ ReturnValue_t cfdp::DestHandler::noticeOfCompletion() {
  return OK;
 }

-ReturnValue_t cfdp::DestHandler::sendKeepAlivePdu() {
-  Fss progress(transactionParams.progress);
-  KeepAlivePduCreator keepAlivePdu(transactionParams.pduConf, progress);
-  size_t serLen = 0;
-  ReturnValue_t result =
-      keepAlivePdu.serialize(pduBuf.data(), serLen, keepAlivePdu.getSerializedSize());
-  if (result != OK) {
-    return result;
-  }
-  return pduSender.sendPdu(PduType::FILE_DIRECTIVE, FileDirective::KEEP_ALIVE, pduBuf.data(),
-                           serLen);
-}
-
 ReturnValue_t cfdp::DestHandler::sendFinishedPdu() {
  FinishedInfo info(transactionParams.conditionCode, transactionParams.deliveryCode,
                    transactionParams.deliveryStatus);
@@ -511,8 +496,6 @@ const cfdp::TransactionId& cfdp::DestHandler::getTransactionId() const {
  return transactionParams.transactionId;
 }

-uint64_t cfdp::DestHandler::getProgress() const { return transactionParams.progress; }
-
 void cfdp::DestHandler::checkAndHandleError(ReturnValue_t result, uint8_t& errorIdx) {
  if (result != OK and errorIdx < 3) {
    fsmRes.errorCodes[errorIdx] = result;
@@ -526,4 +509,4 @@ void cfdp::DestHandler::setEventReporter(EventReportingProxyIF& reporter) {

 const cfdp::DestHandlerParams& cfdp::DestHandler::getDestHandlerParams() const {
  return destParams;
-}
+}
@@ -101,8 +101,6 @@ class DestHandler {

  [[nodiscard]] CfdpState getCfdpState() const;
  [[nodiscard]] TransactionStep getTransactionStep() const;
-  [[nodiscard]] uint64_t getProgress() const;
-  ReturnValue_t sendKeepAlivePdu();
  [[nodiscard]] const TransactionId& getTransactionId() const;
  [[nodiscard]] const DestHandlerParams& getDestHandlerParams() const;

@@ -19,13 +19,13 @@ struct FsfwParams {
 };

 namespace events {
-static constexpr Event PDU_SEND_ERROR = event::makeEvent<SSID, 1, severity::LOW>();
-static constexpr Event SERIALIZATION_ERROR = event::makeEvent<SSID, 2, severity::LOW>();
-static constexpr Event FILESTORE_ERROR = event::makeEvent<SSID, 3, severity::LOW>();
+static constexpr Event PDU_SEND_ERROR = event::makeEvent(SSID, 1, severity::LOW);
+static constexpr Event SERIALIZATION_ERROR = event::makeEvent(SSID, 2, severity::LOW);
+static constexpr Event FILESTORE_ERROR = event::makeEvent(SSID, 3, severity::LOW);
 //! [EXPORT] : [COMMENT] P1: Transaction step ID, P2: 0 for source file name, 1 for dest file name
-static constexpr Event FILENAME_TOO_LARGE_ERROR = event::makeEvent<SSID, 4, severity::LOW>();
+static constexpr Event FILENAME_TOO_LARGE_ERROR = event::makeEvent(SSID, 4, severity::LOW);
 //! [EXPORT] : [COMMENT] CFDP request handling failed. P2: Returncode.
-static constexpr Event HANDLING_CFDP_REQUEST_FAILED = event::makeEvent<SSID, 5, severity::LOW>();
+static constexpr Event HANDLING_CFDP_REQUEST_FAILED = event::makeEvent(SSID, 5, severity::LOW);
 }  // namespace events

 static constexpr ReturnValue_t SOURCE_TRANSACTION_PENDING = returnvalue::makeCode(CID, 0);
@@ -14,7 +14,6 @@ class KeepAlivePduCreator : public FileDirectiveCreator {

  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
                          Endianness streamEndianness) const override;
-  using FileDirectiveCreator::serialize;

 private:
  cfdp::Fss& progress;
@@ -34,12 +34,11 @@ class ExtendedControllerBase : public ControllerBase,
  ActionHelper actionHelper;

  // Periodic HK methods, default method assumes that no shared pool is required.
-  datapool::SharedPool* getOptionalSharedPool() override = 0;
+  virtual datapool::SharedPool* getOptionalSharedPool() override;

  // Periodic HK abstract methods.
-  ReturnValue_t serializeHkDataset(dp::sid_t structureId, uint8_t* buf,
-                                   size_t maxSize) override = 0;
-  ReturnValue_t specifyHkDatasets(std::vector<hk::SetSpecification>& setList) override = 0;
+  ReturnValue_t serializeHkDataset(dp::sid_t structureId, uint8_t* buf, size_t maxSize) = 0;
+  ReturnValue_t specifyHkDatasets(std::vector<hk::SetSpecification>& setList) = 0;

  /**
   * Implemented by child class. Handle all command messages which are
@@ -48,14 +48,6 @@ PoolObjectBase::PoolObjectBase(object_id_t poolOwner, id_t poolId, DataSetIF* da
    return;
  }
  sharedPool = hkOwner->getOptionalSharedPool();
-  if (sharedPool == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "PoolObjectBase: HK owner 0x" << std::hex << poolOwner << std::dec
-               << "does not have a shared pool " << std::endl;
-#else
-    sif::printError("PoolObjectBase: HK owner 0x%08x does not have a shared pool\n", poolOwner);
-#endif
-  }

  if (dataSet != nullptr) {
    dataSet->registerVariable(this);
@@ -9,9 +9,9 @@

 PoolDataSetBase::PoolDataSetBase(PoolVariableIF** registeredVariablesArray,
                                 const size_t maxFillCount, bool serializeWithValidityBlob)
-    : serializeWithValidityBlob(serializeWithValidityBlob),
-      registeredVariables(registeredVariablesArray),
-      maxFillCount(maxFillCount) {}
+    : registeredVariables(registeredVariablesArray),
+      maxFillCount(maxFillCount),
+      serializeWithValidityBlob(serializeWithValidityBlob) {}

 PoolDataSetBase::~PoolDataSetBase() = default;

@@ -251,9 +251,6 @@ size_t PoolDataSetBase::getSerializedSize() const {
  for (uint16_t count = 0; count < fillCount; count++) {
    size += registeredVariables[count]->getSerializedSize();
  }
-  if (serializeWithValidityBlob) {
-    size += std::ceil(static_cast<float>(fillCount) / 8.0);
-  }
  return size;
 }

@@ -139,8 +139,6 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
   */
  void setChildrenValidity(bool valid);

-  bool serializeWithValidityBlob = false;
-
 protected:
  /**
   * @brief	The fill_count attribute ensures that the variables
@@ -168,6 +166,7 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
   */
  PoolVariableIF** registeredVariables = nullptr;
  const size_t maxFillCount = 0;
+  bool serializeWithValidityBlob = false;

  void setContainer(PoolVariableIF** variablesContainer);
  PoolVariableIF** getContainer() const;
@@ -20,9 +20,9 @@ class PoolReadGuard {
      if (readResult != returnvalue::OK) {
 #if FSFW_VERBOSE_LEVEL == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "PoolReadGuard: Read failed!" << std::endl;
+        sif::error << "PoolReadHelper: Read failed!" << std::endl;
 #else
-        sif::printError("PoolReadGuard: Read failed!\n");
+        sif::printError("PoolReadHelper: Read failed!\n");
 #endif /* FSFW_PRINT_VERBOSITY_LEVEL == 1 */
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
      }
@@ -210,7 +210,6 @@ inline ReturnValue_t PoolVariable<T>::readWithoutLock() {
  }

  this->value = *(poolEntry->getDataPtr());
-  this->valid = poolEntry->getValid();
  return returnvalue::OK;
 }

@@ -242,7 +241,6 @@ ReturnValue_t PoolVariable<T>::commitWithoutLock() {
  }

  *(poolEntry->getDataPtr()) = this->value;
-  poolEntry->setValid(this->valid);
  return returnvalue::OK;
 }

@@ -3,7 +3,7 @@
 using namespace dp;

 SharedSet::SharedSet(dp::SharedPool& sharedPool, uint32_t setId, const size_t maxNumberOfVariables,
-                     bool serializeWithValidityBlob)
+                     bool serializeWithValídityBlob)
    : SharedSetBase(sharedPool, setId, nullptr, maxNumberOfVariables, serializeWithValidityBlob),
      poolVarList(maxNumberOfVariables) {
  this->setContainer(poolVarList.data());
@@ -105,6 +105,9 @@ ReturnValue_t SharedSetBase::deSerialize(const uint8_t **buffer, size_t *size,

 ReturnValue_t SharedSetBase::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                       SerializeIF::Endianness streamEndianness) const {
+  if (serializeWithValidityBlob) {
+    return base.doSerializeWithValidityBlob(buffer, size, maxSize, streamEndianness);
+  }
  return base.serialize(buffer, size, maxSize, streamEndianness);
 }

@@ -140,17 +143,10 @@ void SharedSetBase::setAllVariablesReadOnly() {
 void SharedSetBase::printSet() { return; }

 ReturnValue_t SharedSetBase::read(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-  lockDataPool(timeoutType, timeoutMs);
-  ReturnValue_t result = base.read(timeoutType, timeoutMs);
-  unlockDataPool();
-  return result;
+  return base.read(timeoutType, timeoutMs);
 }
-
 ReturnValue_t SharedSetBase::commit(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
-  lockDataPool(timeoutType, timeoutMs);
-  ReturnValue_t result = base.commit(timeoutType, timeoutMs);
-  unlockDataPool();
-  return result;
+  return base.commit(timeoutType, timeoutMs);
 }
 uint16_t SharedSetBase::getFillCount() const { return base.getFillCount(); }

@@ -162,8 +158,3 @@ void SharedSetBase::setContainer(PoolVariableIF **variablesContainer) {
  return base.setContainer(variablesContainer);
 }
 PoolVariableIF **SharedSetBase::getContainer() const { return base.getContainer(); }
-
-void SharedSetBase::updateValidityBlobSerialization(bool enable) {
-  base.serializeWithValidityBlob = enable;
-}
-bool SharedSetBase::getValidityBlobSerialization() const { return base.serializeWithValidityBlob; }
@@ -159,8 +159,11 @@ class SharedSetBase : public SerializeIF, public PoolDataSetIF {
   */
  void setChildrenValidity(bool valid);

-  void updateValidityBlobSerialization(bool enable);
-  bool getValidityBlobSerialization() const;
+  /**
+   * If the valid state of a dataset is always relevant to the whole
+   * data set we can use this flag.
+   */
+  bool serializeWithValidityBlob = false;

 protected:
  PoolDataSetBase base;
@@ -71,8 +71,7 @@ bool AssemblyBase::handleChildrenChangedHealth() {
  if (iter == childrenMap.end()) {
    return false;
  }
-  HealthState healthState =
-      healthHelper.healthTable->getHealth(convertToDeviceObjectId(iter->first));
+  HealthState healthState = healthHelper.healthTable->getHealth(iter->first);
  if (healthState == HasHealthIF::NEEDS_RECOVERY) {
    triggerEvent(TRYING_RECOVERY, iter->first, 0);
    recoveryState = RECOVERY_STARTED;
@@ -92,14 +91,10 @@ bool AssemblyBase::handleChildrenChangedHealth() {
 void AssemblyBase::handleChildrenTransition() {
  if (commandsOutstanding <= 0) {
    switch (internalState) {
-      case STATE_NEED_SECOND_STEP: {
+      case STATE_NEED_SECOND_STEP:
        internalState = STATE_SECOND_STEP;
-        ReturnValue_t result = commandChildren(targetMode, targetSubmode);
-        if (result == NEED_SECOND_STEP) {
-          internalState = STATE_NEED_SECOND_STEP;
-        }
+        commandChildren(targetMode, targetSubmode);
        return;
-      }
      case STATE_OVERWRITE_HEALTH: {
        internalState = STATE_SINGLE_STEP;
        ReturnValue_t result = commandChildren(mode, submode);
@@ -175,7 +170,7 @@ ReturnValue_t AssemblyBase::checkChildrenStateOff() {

 ReturnValue_t AssemblyBase::checkChildOff(uint32_t objectId) {
  ChildInfo childInfo = childrenMap.find(objectId)->second;
-  if (healthHelper.healthTable->isCommandable(convertToDeviceObjectId(objectId))) {
+  if (healthHelper.healthTable->isCommandable(objectId)) {
    if (childInfo.submode != SUBMODE_NONE) {
      return returnvalue::FAILED;
    } else {
@@ -232,7 +227,7 @@ bool AssemblyBase::checkAndHandleRecovery() {
    case RECOVERY_STARTED:
      // The recovery was already start in #handleChildrenChangedHealth and we just need
      // to wait for an off time period.
-      // The timeout can be defined by #setRecoveryWaitTimer
+      // TODO: make time period configurable
      recoveryState = RECOVERY_WAIT;
      recoveryOffTimer.resetTimer();
      return true;
@@ -240,14 +235,14 @@ bool AssemblyBase::checkAndHandleRecovery() {
      if (recoveryOffTimer.isBusy()) {
        return true;
      }
-      triggerEvent(RECOVERY_WAITING, recoveringDevice->first);
+      triggerEvent(RECOVERY_STEP, 0);
      sendHealthCommand(recoveringDevice->second.commandQueue, HEALTHY);
      internalState = STATE_NONE;
      recoveryState = RECOVERY_ONGOING;
      // Don't check state!
      return true;
    case RECOVERY_ONGOING:
-      triggerEvent(RECOVERY_RESTARTING, recoveringDevice->first);
+      triggerEvent(RECOVERY_STEP, 1);
      recoveryState = RECOVERY_ONGOING_2;
      recoveringDevice->second.healthChanged = false;
      // Device should be healthy again, so restart a transition.
@@ -255,7 +250,7 @@ bool AssemblyBase::checkAndHandleRecovery() {
      doStartTransition(targetMode, targetSubmode);
      return true;
    case RECOVERY_ONGOING_2:
-      triggerEvent(RECOVERY_DONE, recoveringDevice->first);
+      triggerEvent(RECOVERY_DONE);
      // Now we're through, but not sure if it was successful.
      recoveryState = RECOVERY_IDLE;
      return false;
@@ -269,14 +264,7 @@ void AssemblyBase::overwriteDeviceHealth(object_id_t objectId, HasHealthIF::Heal
  triggerEvent(OVERWRITING_HEALTH, objectId, oldHealth);
  internalState = STATE_OVERWRITE_HEALTH;
  modeHelper.setForced(true);
-  if (childrenMap.find(objectId) != childrenMap.end()) {
-    sendHealthCommand(childrenMap.at(objectId).commandQueue, EXTERNAL_CONTROL);
-  } else {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::debug << std::hex << SystemObject::getObjectId() << ": invalid mode table entry"
-               << std::endl;
-#endif
-  }
+  sendHealthCommand(childrenMap[objectId].commandQueue, EXTERNAL_CONTROL);
 }

 void AssemblyBase::triggerModeHelperEvents(Mode_t mode, Submode_t submode) {
@@ -286,7 +274,3 @@ void AssemblyBase::triggerModeHelperEvents(Mode_t mode, Submode_t submode) {
    triggerEvent(CHANGING_MODE, mode, submode);
  }
 }
-
-void AssemblyBase::setRecoveryWaitTimer(uint32_t timeoutMS) {
-  recoveryOffTimer.setTimeout(timeoutMS);
-}
@@ -206,8 +206,6 @@ class AssemblyBase : public SubsystemBase {
  void overwriteDeviceHealth(object_id_t objectId, HasHealthIF::HealthState oldHealth);

  void triggerModeHelperEvents(Mode_t mode, Submode_t submode);
-
-  void setRecoveryWaitTimer(uint32_t timeoutMS);
 };

 #endif /* FSFW_DEVICEHANDLERS_ASSEMBLYBASE_H_ */
@@ -148,24 +148,20 @@ class FreshDeviceHandlerBase : public SystemObject,
  // System Object overrides.
  ReturnValue_t initialize() override;

+  // Default implementation assumes that no optional shared pool is required.
+  datapool::SharedPool* getOptionalSharedPool() override;
+
  /**
   * This function is implemented to serialize a housekeeping packet when a HK message to
-   * generate the packet is received, or periodic generation is necessary. The user should serialize
-   * the HK set into the provided buffer, which will have the size specified in the set
-   * specification.
-   */
-  ReturnValue_t serializeHkDataset(dp::sid_t structureId, uint8_t* buf,
-                                   size_t maxSize) override = 0;
-  /**
-   * This function is implemented by the user to specify the available housekeeping sets.
+   * generate the packet is received, or periodic generation is necessary. The user should serialize the HK
+   * set into the provided buffer, which will have the size specified in the set specification.
   */
+  ReturnValue_t serializeHkDataset(dp::sid_t structureId, uint8_t* buf, size_t maxSize) override = 0;
+    /**
+     * This function is implemented by the user to specify the available housekeeping sets.
+     */
  ReturnValue_t specifyHkDatasets(std::vector<hk::SetSpecification>& setList) override = 0;

-  /*
-   *  If this device handler has an optional pool, return it. Otherwise, nullptr can be returned.
-   */
-  datapool::SharedPool* getOptionalSharedPool() override = 0;
-
  /**
   * Implemented by child class. Handle all command messages which are
   * not health, mode, action or housekeeping messages.
@@ -206,6 +202,7 @@ class FreshDeviceHandlerBase : public SystemObject,
   * @return
   */
  virtual ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t initializeAfterTaskCreation() override;

  /**
   * This calls the FDIR instance event trigger function.
@@ -14,6 +14,8 @@ enum Severity : EventSeverity_t { INFO = 1, LOW = 2, MEDIUM = 3, HIGH = 4 };

 }  // namespace severity

+#define MAKE_EVENT(id, severity) (((severity) << 16) + (SUBSYSTEM_ID * 100) + (id))
+
 typedef uint32_t Event;

 namespace event {
@@ -22,14 +24,11 @@ constexpr EventId_t getEventId(Event event) { return (event & 0xFFFF); }

 constexpr EventSeverity_t getSeverity(Event event) { return ((event >> 16) & 0xFF); }

-template <uint8_t subsystemId, UniqueEventId_t uniqueEventId, EventSeverity_t eventSeverity>
-constexpr Event makeEvent() {
-  static_assert(uniqueEventId < 100, "The unique event ID must be smaller than 100!");
+constexpr Event makeEvent(uint8_t subsystemId, UniqueEventId_t uniqueEventId,
+                          EventSeverity_t eventSeverity) {
  return (eventSeverity << 16) + (subsystemId * 100) + uniqueEventId;
 }

 }  // namespace event

-#define MAKE_EVENT(id, severity) event::makeEvent<SUBSYSTEM_ID, id, severity>();
-
 #endif /* EVENTOBJECT_EVENT_H_ */
@@ -27,19 +27,13 @@ class HasHealthIF {
  static const Event CHILD_PROBLEMS = MAKE_EVENT(8, severity::LOW);
  //! Assembly overwrites health information of children to keep satellite alive.
  static const Event OVERWRITING_HEALTH = MAKE_EVENT(9, severity::LOW);
-  //! Someone starts a recovery of a component (typically power-cycle).
-  //! P1: Object Id of the recovering device.
+  //! Someone starts a recovery of a component (typically power-cycle). No parameters.
  static const Event TRYING_RECOVERY = MAKE_EVENT(10, severity::MEDIUM);
+  //! Recovery is ongoing. Comes twice during recovery.
+  //! P1: 0 for the first, 1 for the second event. P2: 0
+  static const Event RECOVERY_STEP = MAKE_EVENT(11, severity::MEDIUM);
  //! Recovery was completed. Not necessarily successful. No parameters.
-  //! P1: Object Id of the recovering device.
  static const Event RECOVERY_DONE = MAKE_EVENT(12, severity::MEDIUM);
-  //! Recovery is ongoing. The recovering device is currently OFF, waiting for restart.
-  //! P1: Object Id of the recovering device.
-  static const Event RECOVERY_WAITING = MAKE_EVENT(13, severity::MEDIUM);
-  //! Recovery is ongoing. Restarting the recovering device.
-  //! P1: Object Id of the recovering device.
-  static const Event RECOVERY_RESTARTING = MAKE_EVENT(14, severity::MEDIUM);
-
  virtual ~HasHealthIF() {}

  virtual MessageQueueId_t getCommandQueue() const = 0;
@@ -17,11 +17,11 @@ void HealthTable::setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t tim
 HealthTable::~HealthTable() { MutexFactory::instance()->deleteMutex(mutex); }

 ReturnValue_t HealthTable::registerObject(object_id_t object,
-                                          HasHealthIF::HealthState initialState) {
+                                          HasHealthIF::HealthState initilialState) {
  if (healthMap.count(object) != 0) {
    return returnvalue::FAILED;
  }
-  healthMap.emplace(object, initialState);
+  healthMap.emplace(object, initilialState);
  return returnvalue::OK;
 }

@@ -112,5 +112,3 @@ ReturnValue_t HealthTable::iterate(HealthEntry* value, bool reset) {
  mapIterator++;
  return result;
 }
-
-MutexIF* HealthTable::getMutex() { return mutex; }
@@ -18,7 +18,7 @@ class HealthTable : public HealthTableIF, public SystemObject {

  /** HealthTableIF overrides */
  virtual ReturnValue_t registerObject(
-      object_id_t object, HasHealthIF::HealthState initialState = HasHealthIF::HEALTHY) override;
+      object_id_t object, HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) override;
  ReturnValue_t removeObject(object_id_t object) override;
  virtual size_t getPrintSize() override;
  virtual void printAll(uint8_t* pointer, size_t maxSize) override;
@@ -28,8 +28,6 @@ class HealthTable : public HealthTableIF, public SystemObject {
  virtual void setHealth(object_id_t object, HasHealthIF::HealthState newState) override;
  virtual HasHealthIF::HealthState getHealth(object_id_t) override;

-  MutexIF* getMutex();
-
 protected:
  using HealthMap = std::map<object_id_t, HasHealthIF::HealthState>;
  using HealthEntry = std::pair<object_id_t, HasHealthIF::HealthState>;
@@ -12,7 +12,7 @@ class HealthTableIF : public ManagesHealthIF {
  virtual ~HealthTableIF() {}

  virtual ReturnValue_t registerObject(
-      object_id_t object, HasHealthIF::HealthState initialState = HasHealthIF::HEALTHY) = 0;
+      object_id_t object, HasHealthIF::HealthState initilialState = HasHealthIF::HEALTHY) = 0;

  virtual ReturnValue_t removeObject(object_id_t objectId) = 0;

@@ -1,4 +1,9 @@
-#pragma once
+#ifndef FSFW_INC_FSFW_HOUSEKEEPING_H_
+#define FSFW_INC_FSFW_HOUSEKEEPING_H_

-#include "fsfw/housekeeping/Dataset.h"
-#include "fsfw/housekeeping/DatasetElement.h"
+#include "src/core/housekeeping/HousekeepingMessage.h"
+#include "src/core/housekeeping/HousekeepingPacketDownlink.h"
+#include "src/core/housekeeping/HousekeepingSetPacket.h"
+#include "src/core/housekeeping/HousekeepingSnapshot.h"
+
+#endif /* FSFW_INC_FSFW_HOUSEKEEPING_H_ */
@@ -17,6 +17,12 @@ class Dataset : public SerializeIF {

  [[nodiscard]] dp::structure_id_t getStructureId() const { return sid; }

+  void setAllChildrenValidity(bool valid) {
+    for (auto &serializable : serializables) {
+      serializable.get().setValid(valid);
+    }
+  }
+
  void addSerializable(const std::reference_wrapper<SerializableWithValidityIF> serializable) {
    serializables.push_back(serializable);
  }
@@ -89,20 +95,11 @@ class Dataset : public SerializeIF {
    return SerializeIF::serialize(buffer, serSize, maxSize, streamEndianness);
  }

-  void setChildrenValidity(bool valid) {
-    for (auto &serializable : serializables) {
-      serializable.get().setValid(valid);
-    }
-  }
-
  [[nodiscard]] size_t getSerializedSize() const override {
    size_t size = 0;
    for (auto &serializable : serializables) {
      size += serializable.get().getSerializedSize();
    }
-    if (serializeWithValidityBlob) {
-      size += std::ceil(static_cast<float>(serializables.size()) / 8.0);
-    }
    return size;
  }

@@ -9,6 +9,7 @@
 #include "fsfw/housekeeping/HousekeepingSnapshot.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/timemanager/CCSDSTime.h"

 using namespace hk;

@@ -16,7 +17,7 @@ PeriodicHelper::PeriodicHelper(GeneratesPeriodicHkIF* owner, MessageQueueIF* que
                               MessageQueueId_t hkDestQueue)
    : hkDestinationId(hkDestQueue) {
  if (owner == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "PeriodicHkHelper", returnvalue::FAILED,
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "LocalDataPoolManager", returnvalue::FAILED,
                        "Invalid supplied owner");
    return;
  }
@@ -83,7 +84,6 @@ ReturnValue_t PeriodicHelper::performHkOperation() {

 ReturnValue_t PeriodicHelper::handleHousekeepingMessage(CommandMessage* message) {
  Command_t command = message->getCommand();
-  MessageQueueId_t sender = message->getSender();
  dp::sid_t sid = HousekeepingMessage::getStructureId(message);
  ReturnValue_t result = returnvalue::OK;
  switch (command) {
@@ -113,7 +113,7 @@ ReturnValue_t PeriodicHelper::handleHousekeepingMessage(CommandMessage* message)
    }

    case (HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT): {
-      return generateHousekeepingPacket(HousekeepingMessage::getStructureId(message), sender);
+      return generateHousekeepingPacket(HousekeepingMessage::getStructureId(message));
    }

    default:
@@ -200,10 +200,11 @@ void PeriodicHelper::performPeriodicHkGeneration(SetSpecification& setSpec, time
    if (result != returnvalue::OK) {
      // Configuration error
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::warning << "hk::PeriodicHelper::performPeriodicHkOperation: HK generation failed."
+      sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed."
                   << std::endl;
 #else
-      sif::printWarning("hk::PeriodicHelper::performPeriodicHkOperation: HK generation failed.\n");
+      sif::printWarning(
+          "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed.\n");
 #endif
      return;
    }
@@ -36,8 +36,6 @@ enum framework_objects : object_id_t {
  TIME_STAMPER = 0x53500010,
  VERIFICATION_REPORTER = 0x53500020,

-  SIF_PRINT_TASK = 0x53600000,
-
  FSFW_OBJECTS_END = 0x53ffffff,
  NO_OBJECT = 0xFFFFFFFF
 };
@@ -41,7 +41,7 @@ UdpTcPollingTask::UdpTcPollingTask(object_id_t objectId, object_id_t tmtcUdpBrid

 [[noreturn]] ReturnValue_t UdpTcPollingTask::performOperation(uint8_t opCode) {
  /* Sender Address is cached here. */
-  struct sockaddr senderAddress{};
+  struct sockaddr senderAddress {};
  socklen_t senderAddressSize = sizeof(senderAddress);

  /* Poll for new UDP datagrams in permanent loop. */
@@ -6,7 +6,6 @@
 #include "FreeRTOS.h"
 #include "fsfw/globalfunctions/timevalOperations.h"
 #include "fsfw/osal/freertos/Timekeeper.h"
-#include "fsfw/serviceinterface/ServiceInterfacePrinter.h"
 #include "task.h"

 // TODO sanitize input?
@@ -48,8 +47,8 @@ ReturnValue_t Clock::getClock(timeval* time) {
 }

 ReturnValue_t Clock::getClockMonotonic(timeval* time) {
-  *time = Timekeeper::instance()->getMonotonicClockOffset() + getUptime();
-  return returnvalue::OK;
+  // TODO: I don't actually know if the timekeeper is monotonic..
+  return getClock_timeval(time);
 }

 ReturnValue_t Clock::getUptime(timeval* uptime) {
@@ -59,7 +58,7 @@ ReturnValue_t Clock::getUptime(timeval* uptime) {
 }

 timeval Clock::getUptime() {
-  TickType_t ticksSinceStart = Timekeeper::instance()->getTicks();
+  TickType_t ticksSinceStart = xTaskGetTickCount();
  return Timekeeper::ticksToTimeval(ticksSinceStart);
 }

@@ -17,13 +17,7 @@ Timekeeper* Timekeeper::instance() {
  return myinstance;
 }

-void Timekeeper::setOffset(const timeval& offset) {
-  if (not monotonicClockInitialized) {
-    this->monotonicClockOffset = offset;
-    monotonicClockInitialized = true;
-  }
-  this->offset = offset;
-}
+void Timekeeper::setOffset(const timeval& offset) { this->offset = offset; }

 timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
  timeval uptime;
@@ -39,5 +33,3 @@ timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
 }

 TickType_t Timekeeper::getTicks() { return xTaskGetTickCount(); }
-
-const timeval Timekeeper::getMonotonicClockOffset() const { return monotonicClockOffset; }
@@ -18,14 +18,9 @@ class Timekeeper {
  Timekeeper();

  timeval offset;
-  // Set when offset is initialized the first time
-  timeval monotonicClockOffset;
-  bool monotonicClockInitialized = false;

  static Timekeeper* myinstance;

-  void setMonotonicClockOffset(const timeval& monotonicClockOffset);
-
 public:
  static Timekeeper* instance();
  virtual ~Timekeeper();
@@ -39,7 +34,6 @@ class Timekeeper {

  const timeval& getOffset() const;
  void setOffset(const timeval& offset);
-  const timeval getMonotonicClockOffset() const;
 };

 #endif /* FRAMEWORK_OSAL_FREERTOS_TIMEKEEPER_H_ */
@@ -173,7 +173,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;
@@ -52,6 +52,6 @@ void TaskFactory::printMissedDeadline() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
  sif::warning << "TaskFactory::printMissedDeadline: " << name << std::endl;
 #else
-  sif::printWarning("TaskFactory::printMissedDeadline: %s\n", name.c_str());
+  sif::printWarning("TaskFactory::printMissedDeadline: %s\n", name);
 #endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
 }
@@ -49,7 +49,7 @@ class Service11TelecommandScheduling final : public PusServiceBase {

  //! [EXPORT] : [COMMENT] Deletion of a TC from the map failed.
  //! P1: First 32 bit of request ID, P2. Last 32 bit of Request ID
-  static constexpr Event TC_DELETION_FAILED = event::makeEvent<SUBSYSTEM_ID, 0, severity::MEDIUM>();
+  static constexpr Event TC_DELETION_FAILED = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);

  // The types of PUS-11 subservices
  enum Subservice : uint8_t {
@@ -1,8 +1,6 @@
 #ifndef FSFW_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
 #define FSFW_PUS_SERVICE8FUNCTIONMANAGEMENT_H_

-#include <cstdint>
-
 #include "fsfw/action/ActionMessage.h"
 #include "fsfw/tmtcservices/CommandingServiceBase.h"

@@ -37,13 +35,6 @@ class Service8FunctionManagement : public CommandingServiceBase {
                             uint16_t commandTimeoutSeconds = 60);
  ~Service8FunctionManagement() override;

-  enum class Subservice : uint8_t {
-    //!< [EXPORT] : [COMMAND] Functional commanding
-    COMMAND_DIRECT_COMMANDING = 128,
-    //!< [EXPORT] : [REPLY] Data reply
-    REPLY_DIRECT_COMMANDING_DATA = 130,
-  };
-
 protected:
  /* CSB abstract functions implementation . See CSB documentation. */
  ReturnValue_t isValidSubservice(uint8_t subservice) override;
@@ -57,6 +48,13 @@ class Service8FunctionManagement : public CommandingServiceBase {
                            bool* isStep) override;

 private:
+  enum class Subservice {
+    //!< [EXPORT] : [COMMAND] Functional commanding
+    COMMAND_DIRECT_COMMANDING = 128,
+    //!< [EXPORT] : [REPLY] Data reply
+    REPLY_DIRECT_COMMANDING_DATA = 130,
+  };
+
  ReturnValue_t checkInterfaceAndAcquireMessageQueue(MessageQueueId_t* messageQueueToSet,
                                                     object_id_t* objectId);
  ReturnValue_t prepareDirectCommand(CommandMessage* message, const uint8_t* tcData,
@@ -1,14 +1,11 @@
 #ifndef FSFW_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
 #define FSFW_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_

-#include <cstdint>
-
 #include "../../action/ActionMessage.h"
 #include "../../objectmanager/SystemObjectIF.h"
-#include "../../returnvalues/returnvalue.h"
 #include "../../serialize/SerialBufferAdapter.h"
+#include "../../serialize/SerialFixedArrayListAdapter.h"
 #include "../../serialize/SerialLinkedListAdapter.h"
-#include "../../serialize/SerializeAdapter.h"
 #include "../../serialize/SerializeElement.h"

 /**
@@ -25,41 +22,14 @@ class DirectCommand
    parametersSize = size;
  }

-  DirectCommand() : parametersSize(0), parameterBuffer(nullptr) {}
-
  ActionId_t getActionId() const { return actionId; }
-  void setActionId(ActionId_t actionId) { this->actionId = actionId; }

  object_id_t getObjectId() const { return objectId; }
-  void setObjectId(object_id_t objectId) { this->objectId = objectId; }

  const uint8_t* getParameters() { return parameterBuffer; }
-  // The given pointer is not deallocated and must outlive the DirectCommand!
-  void setParameters(const uint8_t* parameters, uint32_t parametersSize) {
-    this->parameterBuffer = parameters;
-    this->parametersSize = parametersSize;
-  }

  uint32_t getParametersSize() const { return parametersSize; }

-  // ^SerializeIF
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                                  Endianness streamEndianness) const override {
-    auto const oldSize = *size;
-    auto result = SerializeAdapter::serialize(&objectId, buffer, size, maxSize, streamEndianness);
-    if (result != returnvalue::OK) return result;
-    result = SerializeAdapter::serialize(&actionId, buffer, size, maxSize - ((*size) - oldSize),
-                                         streamEndianness);
-    if (result != returnvalue::OK) return result;
-
-    auto remainingSize = maxSize - ((*size) - oldSize);
-    if (remainingSize < parametersSize) return returnvalue::FAILED;
-    memcpy(*buffer, parameterBuffer, parametersSize);
-    *size += parametersSize;
-
-    return returnvalue::OK;
-  }
-
 private:
  DirectCommand(const DirectCommand& command);
  object_id_t objectId = 0;
@@ -1,5 +1,4 @@
 target_sources(
  ${LIB_FSFW_NAME}
  PRIVATE ServiceInterfaceStream.cpp ServiceInterfaceBuffer.cpp
-          ServiceInterfacePrinter.cpp ServiceInterfacePrinterTask.cpp
-          ServiceInterfacePrinterMessage.cpp)
+          ServiceInterfacePrinter.cpp)
@@ -1,13 +1,9 @@
 #include "fsfw/serviceinterface/ServiceInterfacePrinter.h"

 #include <cstdarg>
+#include <cstdint>

-#include "ServiceInterfacePrinterMessage.h"
-#include "etl/bitset.h"
-#include "etl/queue.h"
 #include "fsfw/FSFW.h"
-#include "fsfw/ipc/MutexGuard.h"
-#include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
 #include "fsfw/timemanager/Clock.h"

@@ -18,33 +14,11 @@ static bool consoleInitialized = false;

 #if FSFW_DISABLE_PRINTOUT == 0

-typedef etl::bitset<fsfwconfig::FSFW_PRINT_BUFFER_AMOUNT> bitset;
-
 static bool addCrAtEnd = false;
-static bool initializedAndReady = false;
-static bool replaceLastCharWithNewline = false;

-bitset bufferState{};
-std::array<char[fsfwconfig::FSFW_PRINT_BUFFER_SIZE], fsfwconfig::FSFW_PRINT_BUFFER_AMOUNT>
-    printBufferArray = {};
+uint8_t printBuffer[fsfwconfig::FSFW_PRINT_BUFFER_SIZE];

-uint32_t droppedMessagesCounter = 0;
-uint32_t droppedMessagesCounterContinuous = 0;
-
-MutexIF* bufferMutex;
-MessageQueueIF* bufferQueue;
-
-size_t selectFreeBuffer() {
-  MutexGuard guard(bufferMutex, MutexIF::TimeoutType::WAITING, 10);
-  const size_t bufferIdx = bufferState.find_first(false);
-  if (bufferIdx == bitset::npos) {
-    return bitset::npos;
-  }
-  bufferState.set(bufferIdx, true);
-  return bufferIdx;
-}
-
-void fsfwPrint(const sif::PrintLevel printType, const char* fmt, va_list arg) {
+void fsfwPrint(sif::PrintLevel printType, const char *fmt, va_list arg) {
 #if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
  if (not consoleInitialized) {
    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
@@ -56,22 +30,14 @@ void fsfwPrint(const sif::PrintLevel printType, const char* fmt, va_list arg) {
  consoleInitialized = true;
 #endif

+  size_t len = 0;
+  char *bufferPosition = reinterpret_cast<char *>(printBuffer);
+
  /* Check logger level */
  if (printType == sif::PrintLevel::NONE or printType > printLevel) {
    return;
  }

-  const bool isReady = initializedAndReady;
-  const size_t bufferIdx = isReady ? selectFreeBuffer() : 0;
-  if (bufferIdx == bitset::npos) {
-    // This will lose updates, but we are mostly concerned with if we are dropping messages
-    ++droppedMessagesCounter;
-    return;
-  }
-
-  size_t len = 0;
-  char* bufferPosition = printBufferArray[bufferIdx];
-
  /* Log message to terminal */

 #if FSFW_COLORED_OUTPUT == 1
@@ -87,16 +53,17 @@ void fsfwPrint(const sif::PrintLevel printType, const char* fmt, va_list arg) {
 #endif

  if (printType == sif::PrintLevel::INFO_LEVEL) {
-    len += sprintf(bufferPosition + len, "INFO   ");
+    len += sprintf(bufferPosition + len, "INFO");
  }
  if (printType == sif::PrintLevel::DEBUG_LEVEL) {
-    len += sprintf(bufferPosition + len, "DEBUG  ");
+    len += sprintf(bufferPosition + len, "DEBUG");
  }
  if (printType == sif::PrintLevel::WARNING_LEVEL) {
    len += sprintf(bufferPosition + len, "WARNING");
  }
+
  if (printType == sif::PrintLevel::ERROR_LEVEL) {
-    len += sprintf(bufferPosition + len, "ERROR  ");
+    len += sprintf(bufferPosition + len, "ERROR");
  }

 #if FSFW_COLORED_OUTPUT == 1
@@ -108,112 +75,55 @@ void fsfwPrint(const sif::PrintLevel printType, const char* fmt, va_list arg) {
  /*
   * Log current time to terminal if desired.
   */
-  len += sprintf(bufferPosition + len, " | %02lu:%02lu:%02lu.%03lu | ", (unsigned long)now.hour,
+  len += sprintf(bufferPosition + len, " | %lu:%02lu:%02lu.%03lu | ", (unsigned long)now.hour,
                 (unsigned long)now.minute, (unsigned long)now.second,
                 (unsigned long)now.usecond / 1000);

-  len += vsnprintf(bufferPosition + len, sizeof(printBufferArray[bufferIdx]) - len, fmt, arg);
+  len += vsnprintf(bufferPosition + len, sizeof(printBuffer) - len, fmt, arg);

  if (addCrAtEnd) {
    len += sprintf(bufferPosition + len, "\r");
  }

-  printBufferArray[bufferIdx][fsfwconfig::FSFW_PRINT_BUFFER_SIZE - 1] = 0;
-
-  if (replaceLastCharWithNewline) {
-    const size_t stringLength = strlen(bufferPosition);
-    const size_t lastCharPosition =
-        etl::min(stringLength - 1, fsfwconfig::FSFW_PRINT_BUFFER_SIZE - 3);
-    const char lastChar = printBufferArray[bufferIdx][lastCharPosition];
-    if (!(lastChar == '\n' or lastChar == '\r')) {
-      printBufferArray[bufferIdx][lastCharPosition + 1] = '\n';
-      printBufferArray[bufferIdx][lastCharPosition + 2] = 0;
-    }
-  }
-
-  if (isReady) {
-    ServiceInterfacePrinterMessage message(bufferIdx);
-    bufferQueue->sendToDefault(&message);
-  } else {
-    printf("%s", printBufferArray[bufferIdx]);
-  }
+  printf("%s", printBuffer);
 }

-void sif::setToAddCrAtEnd(const bool addCrAtEnd_) { addCrAtEnd = addCrAtEnd_; }
-
-void sif::setReplaceLastCharWithNewline(const bool replace) {
-  replaceLastCharWithNewline = replace;
-}
-
-void sif::printInfo(const char* fmt, ...) {
+void sif::printInfo(const char *fmt, ...) {
  va_list args;
  va_start(args, fmt);
  fsfwPrint(sif::PrintLevel::INFO_LEVEL, fmt, args);
  va_end(args);
 }

-void sif::printWarning(const char* fmt, ...) {
+void sif::printWarning(const char *fmt, ...) {
  va_list args;
  va_start(args, fmt);
  fsfwPrint(sif::PrintLevel::WARNING_LEVEL, fmt, args);
  va_end(args);
 }

-void sif::printDebug(const char* fmt, ...) {
+void sif::printDebug(const char *fmt, ...) {
  va_list args;
  va_start(args, fmt);
  fsfwPrint(sif::PrintLevel::DEBUG_LEVEL, fmt, args);
  va_end(args);
 }

-void sif::printError(const char* fmt, ...) {
+void sif::setToAddCrAtEnd(bool addCrAtEnd_) { addCrAtEnd = addCrAtEnd_; }
+
+void sif::printError(const char *fmt, ...) {
  va_list args;
  va_start(args, fmt);
  fsfwPrint(sif::PrintLevel::ERROR_LEVEL, fmt, args);
  va_end(args);
 }

-void sif::printCallback() {
-  if (!initializedAndReady) {
-    initializedAndReady = true;
-  }
-  uint32_t bitmask = 0;
-  ServiceInterfacePrinterMessage message;
-  while (bufferQueue->receiveMessage(&message) == returnvalue::OK) {
-    const size_t bufferIdx = message.getBufferIndex();
-    bitmask |= 1 << bufferIdx;
-    printf("%s", printBufferArray[bufferIdx]);
-  }
-  {
-    MutexGuard guard(bufferMutex, MutexIF::TimeoutType::BLOCKING);
-    bufferState &= ~bitmask;
-  }
-  const uint32_t droppedMessages = droppedMessagesCounter;
-  droppedMessagesCounter = 0;
-  droppedMessagesCounterContinuous += droppedMessages;
-  if (droppedMessages != 0) {
-    sif::printError("ServiceInterfacePrinter: Dropped ca. %i messages\n", droppedMessages);
-  }
-}
-
-void sif::init() {
-  bufferMutex = MutexFactory::instance()->createMutex();
-  bufferQueue = QueueFactory::instance()->createMessageQueue(fsfwconfig::FSFW_PRINT_BUFFER_AMOUNT);
-  bufferQueue->setDefaultDestination(bufferQueue->getId());
-}
-
-uint32_t sif::getDroppedMessagesCount() { return droppedMessagesCounterContinuous; }
-
 #else

-void sif::printInfo(const char* fmt, ...) {}
-void sif::printWarning(const char* fmt, ...) {}
-void sif::printDebug(const char* fmt, ...) {}
-void sif::printError(const char* fmt, ...) {}
-
-void sif::printCallback() {}
-void sif::init() {}
-uint32_t sif::getDroppedMessagesCount() { return 0; }
+void sif::printInfo(const char *fmt, ...) {}
+void sif::printWarning(const char *fmt, ...) {}
+void sif::printDebug(const char *fmt, ...) {}
+void sif::printError(const char *fmt, ...) {}

 #endif /* FSFW_DISABLE_PRINTOUT == 0 */

@@ -39,11 +39,6 @@ PrintLevel getPrintLevel();

 void setToAddCrAtEnd(bool addCrAtEnd_);

-/**
- * Replaces the last char of a print buffer with a newline
- */
-void setReplaceLastCharWithNewline(bool replace);
-
 /**
 * These functions can be used like the C stdio printf and forward the
 * supplied formatted string arguments to a printf function.
@@ -56,21 +51,6 @@ void printWarning(const char* fmt, ...);
 void printDebug(const char* fmt, ...);
 void printError(const char* fmt, ...);

-/**
- * This function is to be called periodically by a dedicated print task.
- */
-void printCallback();
-
-/**
- * Initializes the global state for the print task.
- */
-void init();
-
-/**
- * Gets the total estimated number of dropped messages
- */
-uint32_t getDroppedMessagesCount();
-
 }  // namespace sif

 #endif /* FSFW_SERVICEINTERFACE_SERVICEINTERFACEPRINTER */
@@ -1,18 +0,0 @@
-#include "ServiceInterfacePrinterMessage.h"
-
-#include <cstring>
-
-ServiceInterfacePrinterMessage::ServiceInterfacePrinterMessage(const size_t bufferIdx) {
-  this->MessageQueueMessage::setMessageSize(sizeof(bufferIdx));
-  this->setBufferIndex(bufferIdx);
-}
-
-void ServiceInterfacePrinterMessage::setBufferIndex(const size_t bufferIdx) {
-  std::memcpy(this->getData(), &bufferIdx, sizeof(bufferIdx));
-}
-
-size_t ServiceInterfacePrinterMessage::getBufferIndex() {
-  size_t tempIdx;
-  std::memcpy(&tempIdx, this->getData(), sizeof(size_t));
-  return tempIdx;
-}
@@ -1,12 +0,0 @@
-#pragma once
-#include "fsfw/ipc/MessageQueueMessage.h"
-
-class ServiceInterfacePrinterMessage : public MessageQueueMessage {
- public:
-  ServiceInterfacePrinterMessage() = default;
-  explicit ServiceInterfacePrinterMessage(size_t bufferIdx);
-  size_t getBufferIndex();
-
- private:
-  void setBufferIndex(size_t bufferIdx);
-};
@@ -1,14 +0,0 @@
-#include "ServiceInterfacePrinterTask.h"
-
-#include "ServiceInterfacePrinter.h"
-#include "fsfw/objectmanager/SystemObject.h"
-
-ServiceInterfacePrinterTask::ServiceInterfacePrinterTask(object_id_t objectId)
-    : SystemObject(objectId) {
-  sif::init();
-}
-
-ReturnValue_t ServiceInterfacePrinterTask::performOperation(uint8_t operationCode) {
-  sif::printCallback();
-  return returnvalue::OK;
-}
@@ -1,10 +0,0 @@
-#pragma once
-
-#include "fsfw/objectmanager/SystemObject.h"
-#include "fsfw/tasks/ExecutableObjectIF.h"
-
-class ServiceInterfacePrinterTask : public ExecutableObjectIF, public SystemObject {
- public:
-  explicit ServiceInterfacePrinterTask(object_id_t objectId);
-  ReturnValue_t performOperation(uint8_t operationCode) override;
-};
@@ -99,7 +99,7 @@ class Subsystem : public SubsystemBase, public HasModeSequenceIF {
    EntryPointer entries;
  };

-  static const uint8_t MAX_NUMBER_OF_TABLES_OR_SEQUENCES = 100;
+  static const uint8_t MAX_NUMBER_OF_TABLES_OR_SEQUENCES = 70;

  static const uint8_t MAX_LENGTH_OF_TABLE_OR_SEQUENCE = 20;

@@ -78,36 +78,23 @@ void SubsystemBase::executeTable(HybridIterator<ModeListEntry> tableIter, Submod
      submodeToCommand = targetSubmode;
    }

-    if (healthHelper.healthTable->hasHealth(convertToDeviceObjectId(object))) {
-      switch (healthHelper.healthTable->getHealth(convertToDeviceObjectId(object))) {
-        case NEEDS_RECOVERY:
-        case FAULTY:
-        case PERMANENT_FAULTY:
-          ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
-                                      SUBMODE_NONE);
-          break;
-        case HEALTHY:
-          if (modeHelper.isForced()) {
-            ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND_FORCED,
-                                        tableIter.value->getMode(), submodeToCommand);
-          } else {
+    if (healthHelper.healthTable->hasHealth(object)) {
+      if (healthHelper.healthTable->isFaulty(object)) {
+        ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND, HasModesIF::MODE_OFF,
+                                    SUBMODE_NONE);
+      } else {
+        if (modeHelper.isForced()) {
+          ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND_FORCED,
+                                      tableIter.value->getMode(), submodeToCommand);
+        } else {
+          if (healthHelper.healthTable->isCommandable(object)) {
            ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
                                        tableIter.value->getMode(), submodeToCommand);
-          }
-          break;
-        case EXTERNAL_CONTROL:
-          if (modeHelper.isForced()) {
-            ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND_FORCED,
-                                        tableIter.value->getMode(), submodeToCommand);
          } else {
            continue;
          }
-          break;
-        default:
-          // This never happens
-          break;
+        }
      }
-
    } else {
      ModeMessage::setModeMessage(&command, ModeMessage::CMD_MODE_COMMAND,
                                  tableIter.value->getMode(), submodeToCommand);
@@ -352,5 +339,3 @@ ReturnValue_t SubsystemBase::registerChild(object_id_t childObjectId, MessageQue
  }
  return returnvalue::OK;
 }
-
-object_id_t SubsystemBase::convertToDeviceObjectId(object_id_t id) { return id; }
@@ -113,8 +113,8 @@ class SubsystemBase : public SystemObject,
   * We need to know the target Submode, as children are able to inherit the submode
   * Still, we have a default for all child implementations which do not use submode inheritance
   */
-  virtual void executeTable(HybridIterator<ModeListEntry> tableIter,
-                            Submode_t targetSubmode = SUBMODE_NONE);
+  void executeTable(HybridIterator<ModeListEntry> tableIter,
+                    Submode_t targetSubmode = SUBMODE_NONE);

  ReturnValue_t updateChildMode(MessageQueueId_t queue, Mode_t mode, Submode_t submode);
  ReturnValue_t updateChildModeByObjId(object_id_t objectId, Mode_t mode, Submode_t submode);
@@ -153,12 +153,6 @@ class SubsystemBase : public SystemObject,
  virtual void announceMode(bool recursive) override;

  virtual void modeChanged();
-
-  /**
-   * @brief Provides an adaptation point for the user to change an objectId into
-   * a different objectId.
-   */
-  virtual object_id_t convertToDeviceObjectId(object_id_t id);
 };

 #endif /* FSFW_SUBSYSTEM_SUBSYSTEMBASE_H_ */
@@ -18,10 +18,6 @@ PusDistributor::PusDistributor(uint16_t setApid, object_id_t setObjectId, Storag

 PusDistributor::~PusDistributor() = default;

-void PusDistributor::setVerificationReporter(object_id_t verificationReporter_) {
-  verificationReporter = verificationReporter_;
-}
-
 ReturnValue_t PusDistributor::selectDestination(MessageQueueId_t& destId) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && PUS_DISTRIBUTOR_DEBUGGING == 1
  store_address_t storeId = currentMessage.getStorageId();
@@ -135,7 +131,8 @@ ReturnValue_t PusDistributor::initialize() {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
  if (verifyChannel == nullptr) {
-    verifyChannel = ObjectManager::instance()->get<VerificationReporterIF>(verificationReporter);
+    verifyChannel =
+        ObjectManager::instance()->get<VerificationReporterIF>(objects::VERIFICATION_REPORTER);
    if (verifyChannel == nullptr) {
      return ObjectManagerIF::CHILD_INIT_FAILED;
    }
@@ -43,10 +43,6 @@ class PusDistributor : public TcDistributorBase,
  [[nodiscard]] MessageQueueId_t getRequestQueue() const override;
  ReturnValue_t initialize() override;
  [[nodiscard]] uint32_t getIdentifier() const override;
-  /**
-   * @brief Can be used to set the verification reporter if another than the default should be used
-   */
-  void setVerificationReporter(object_id_t verificationReporter_);

 protected:
  struct ServiceInfo {
@@ -79,8 +75,6 @@ class PusDistributor : public TcDistributorBase,
   */
  ReturnValue_t tcStatus;

-  object_id_t verificationReporter = objects::VERIFICATION_REPORTER;
-
  /**
   * This method reads the packet service, checks if such a service is
   * registered and forwards the packet to the destination.
@@ -25,7 +25,7 @@ static constexpr ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE(11)

 static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TMTC_DISTRIBUTION;
 //! P1: Returnvalue, P2: 0 for TM issues, 1 for TC issues
-static constexpr Event HANDLE_PACKET_FAILED = event::makeEvent<SUBSYSTEM_ID, 0, severity::LOW>();
+static constexpr Event HANDLE_PACKET_FAILED = event::makeEvent(SUBSYSTEM_ID, 0, severity::LOW);

 };  // namespace tmtcdistrib
 #endif  // FSFW_TMTCPACKET_DEFINITIONS_H
@@ -142,7 +142,7 @@ class TemperatureSensor : public AbstractTemperatureSensor {

      deltaTime = (uptime.tv_sec + uptime.tv_usec / 1000000.) -
                  (uptimeOfOldTemperature.tv_sec + uptimeOfOldTemperature.tv_usec / 1000000.);
-      deltaTemp = oldTemperature - outputTemperature.value;
+      deltaTemp = oldTemperature - outputTemperature;
      if (deltaTemp < 0) {
        deltaTemp = -deltaTemp;
      }
@@ -160,13 +160,13 @@ class TemperatureSensor : public AbstractTemperatureSensor {
      outputTemperature.setValid(PoolVariableIF::INVALID);
      outputTemperature = thermal::INVALID_TEMPERATURE;
    } else {
-      oldTemperature = outputTemperature.value;
+      oldTemperature = outputTemperature;
      uptimeOfOldTemperature = uptime;
    }
  }

 public:
-  float getTemperature() { return outputTemperature.value; }
+  float getTemperature() { return outputTemperature; }

  bool isValid() { return outputTemperature.isValid(); }

@@ -192,8 +192,6 @@ class Clock {
  static MutexIF *timeMutex;
  static uint16_t leapSeconds;
  static bool leapSecondsSet;
-  static bool monotonicClockInitialized;
-  static timeval monotonicClockOffset;
 };

 #endif /* FSFW_TIMEMANAGER_CLOCK_H_ */
@@ -114,11 +114,6 @@ void TmStoreMessage::setDownlinkContentTimeMessage(CommandMessage* cmd, store_ad
  cmd->setParameter2(storeId.raw);
 }

-void TmStoreMessage::setStopDownlinkContentMessage(CommandMessage* cmd, store_address_t storeId) {
-  cmd->setCommand(STOP_DOWNLINK_STORE_CONTENT);
-  cmd->setParameter2(storeId.raw);
-}
-
 uint32_t TmStoreMessage::getAddressLow(CommandMessage* cmd) { return cmd->getParameter(); }
 uint32_t TmStoreMessage::getAddressHigh(CommandMessage* cmd) { return cmd->getParameter2(); }

@@ -21,7 +21,6 @@ class TmStoreMessage {
  static void setStoreCatalogueReportMessage(CommandMessage* cmd, object_id_t objectId,
                                             store_address_t storeId);
  static void setDownlinkContentTimeMessage(CommandMessage* cmd, store_address_t storeId);
-  static void setStopDownlinkContentMessage(CommandMessage* cmd, store_address_t storeId);
  static void setIndexReportMessage(CommandMessage* cmd, store_address_t storeId);
  static ReturnValue_t setDeleteBlocksMessage(CommandMessage* cmd, uint32_t addressLow,
                                              uint32_t addressHigh);
@@ -55,7 +54,6 @@ class TmStoreMessage {
  static const Command_t DOWNLINK_STORE_CONTENT_BLOCKS = MAKE_COMMAND_ID(12);
  static const Command_t REPORT_INDEX_REQUEST = MAKE_COMMAND_ID(13);
  static const Command_t INDEX_REPORT = MAKE_COMMAND_ID(14);
-  static const Command_t STOP_DOWNLINK_STORE_CONTENT = MAKE_COMMAND_ID(15);

 private:
  TmStoreMessage();
@@ -128,7 +128,7 @@ ReturnValue_t CommandingServiceBase::initialize() {

  if (verificationReporter == nullptr) {
    verificationReporter =
-        ObjectManager::instance()->get<VerificationReporterIF>(verificationReporterId);
+        ObjectManager::instance()->get<VerificationReporterIF>(objects::VERIFICATION_REPORTER);
    if (verificationReporter == nullptr) {
      return ObjectManagerIF::CHILD_INIT_FAILED;
    }
@@ -136,10 +136,6 @@ ReturnValue_t CommandingServiceBase::initialize() {
  return returnvalue::OK;
 }

-void CommandingServiceBase::setVerificationReporter(object_id_t verificationReporterId_) {
-  verificationReporterId = verificationReporterId_;
-}
-
 void CommandingServiceBase::handleCommandQueue() {
  CommandMessage reply;
  ReturnValue_t result;
@@ -126,8 +126,6 @@ class CommandingServiceBase : public SystemObject,

  ReturnValue_t initialize() override;

-  void setVerificationReporter(object_id_t verificationReporterId_);
-
  /**
   * Implementation of ExecutableObjectIF function
   *
@@ -264,8 +262,6 @@ class CommandingServiceBase : public SystemObject,

  const uint16_t timeoutSeconds;

-  object_id_t verificationReporterId = objects::VERIFICATION_REPORTER;
-
  PusTcReader tcReader;
  TmStoreHelper tmStoreHelper;
  TmSendHelper tmSendHelper;
@@ -111,7 +111,7 @@ ReturnValue_t PusServiceBase::initialize() {
  }

  if (psbParams.pusDistributor == nullptr) {
-    psbParams.pusDistributor = ObjectManager::instance()->get<PusDistributorIF>(pusDistributor);
+    psbParams.pusDistributor = ObjectManager::instance()->get<PusDistributorIF>(PUS_DISTRIBUTOR);
    if (psbParams.pusDistributor != nullptr) {
      registerService(*psbParams.pusDistributor);
    }
@@ -126,7 +126,7 @@ ReturnValue_t PusServiceBase::initialize() {

  if (psbParams.verifReporter == nullptr) {
    psbParams.verifReporter =
-        ObjectManager::instance()->get<VerificationReporterIF>(verificationReporter);
+        ObjectManager::instance()->get<VerificationReporterIF>(objects::VERIFICATION_REPORTER);
    if (psbParams.verifReporter == nullptr) {
      return ObjectManagerIF::CHILD_INIT_FAILED;
    }
@@ -134,14 +134,6 @@ ReturnValue_t PusServiceBase::initialize() {
  return returnvalue::OK;
 }

-void PusServiceBase::setPusDistributor(object_id_t pusDistributor_) {
-  pusDistributor = pusDistributor_;
-}
-
-void PusServiceBase::setVerificationReporter(object_id_t verificationReporter_) {
-  verificationReporter = verificationReporter_;
-}
-
 void PusServiceBase::setTcPool(StorageManagerIF& tcPool) { psbParams.tcPool = &tcPool; }

 void PusServiceBase::setErrorReporter(InternalErrorReporterIF& errReporter_) {
@@ -201,9 +201,6 @@ class PusServiceBase : public ExecutableObjectIF,
  void setTaskIF(PeriodicTaskIF* taskHandle) override;
  [[nodiscard]] const char* getName() const override;

-  void setPusDistributor(object_id_t pusDistributor_);
-  void setVerificationReporter(object_id_t verificationReporter_);
-
 protected:
  /**
   * @brief   Handle to the underlying task
@@ -231,9 +228,6 @@ class PusServiceBase : public ExecutableObjectIF,
  static object_id_t PACKET_DESTINATION;
  static object_id_t PUS_DISTRIBUTOR;

-  object_id_t pusDistributor = PUS_DISTRIBUTOR;
-  object_id_t verificationReporter = objects::VERIFICATION_REPORTER;
-
 private:
  void handleRequestQueue();
 };
@@ -116,7 +116,7 @@ class CommandExecutor {
  int currentFd = 0;
  bool printOutput = true;
  std::vector<char> readVec;
-  struct pollfd waiter{};
+  struct pollfd waiter {};
  SimpleRingBuffer* ringBuffer = nullptr;
  DynamicFIFO<uint16_t>* sizesFifo = nullptr;

@@ -62,7 +62,6 @@ TEST_CASE("Pool Dataset Test", "[datapool]") {
    size_t serLen = 0;
    uint8_t* dataPtr = buf;
    dataset.serializeWithValidityBlob = true;
-    CHECK(dataset.getSerializedSize() == 6);
    CHECK(dataset.serialize(&dataPtr, &serLen, sizeof(buf), SerializeIF::Endianness::NETWORK) ==
          returnvalue::OK);
    CHECK(buf[5] == 0b11000000);
@@ -71,7 +70,7 @@ TEST_CASE("Pool Dataset Test", "[datapool]") {
  SECTION("Larger Pool Dataset Serialization With Validity") {
    uint8_t buf[64]{};
    TestDatasetLarger datasetLarge;
-    datasetLarge.setChildrenValidity(true);
+    datasetLarge.setAllChildrenValidity(true);
    size_t serLen = 0;
    uint8_t* dataPtr = buf;
    datasetLarge.serializeWithValidityBlob = true;
@@ -23,7 +23,6 @@ TEST_CASE("DataSetTest", "[datapool]") {
  SECTION("BasicTest") {
    /* Test some basic functions */
    CHECK(localSet.getReportingEnabled() == false);
-    CHECK(localSet.getSerializedSize() == 11);
    CHECK(localSet.getLocalPoolIdsSerializedSize() == 3 * sizeof(dp::id_t));
    CHECK(localSet.getStructureId() == lpool::testSid1);
    CHECK(localSet.getCreatorObjectId() == objects::TEST_LOCAL_POOL_OWNER_BASE);
@@ -157,7 +156,7 @@ TEST_CASE("DataSetTest", "[datapool]") {
  }

  SECTION("Serialize with Validity Blob") {
-    localSet.updateValidityBlobSerialization(true);
+    localSet.serializeWithValidityBlob = true;
    CHECK(!localSet.localPoolVarUint8.isValid());
    CHECK(!localSet.localPoolUint16Vec.isValid());
    CHECK(!localSet.localPoolVarFloat.isValid());
@@ -169,7 +168,6 @@ TEST_CASE("DataSetTest", "[datapool]") {
    // Already reserve additional space for validity buffer, will be needed later
    uint8_t buffer[128]{};
    uint8_t* buffPtr = buffer;
-    CHECK(localSet.getSerializedSize() == 12);
    CHECK(localSet.serialize(&buffPtr, &serSize, sizeof(buffer),
                             SerializeIF::Endianness::MACHINE) == returnvalue::OK);
    CHECK(serSize == 12);
@@ -38,7 +38,7 @@ TEST_CASE("PUS TM Reader", "[pus-tm-reader]") {
      readerPtr->setTimeReader(&timeStamperAndReader);
      deleteReader = true;
    }
-    REQUIRE(not*readerPtr);
+    REQUIRE(not *readerPtr);
    REQUIRE(readerPtr->isNull());
    REQUIRE(readerPtr->parseDataWithCrcCheck() == returnvalue::OK);
    REQUIRE(not readerPtr->isNull());