Update and clean up HK and Local Pool Modules

CHANGELOG.md

@@ -26,7 +26,6 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## Added
 
-- 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.
@@ -35,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.

CMakeLists.txt

@@ -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)

misc/archive/MgmRM3100Handler.h

@@ -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);

src/fsfw/cfdp/handler/defs.h

@@ -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);

src/fsfw/controller/ExtendedControllerBase.h

@@ -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

src/fsfw/datapool/LocalPoolObjectBase.cpp

@@ -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);

src/fsfw/datapool/PoolDataSetBase.cpp

@@ -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;
 }
 

src/fsfw/datapool/PoolDataSetBase.h

@@ -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;

src/fsfw/datapool/PoolReadGuard.h

@@ -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 */
       }

src/fsfw/datapool/PoolVariable.h

@@ -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;
 }
 

src/fsfw/datapool/SharedSet.cpp

@@ -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());

src/fsfw/datapool/SharedSetBase.cpp

@@ -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; }

src/fsfw/datapool/SharedSetBase.h

@@ -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;

src/fsfw/devicehandlers/AssemblyBase.cpp

@@ -71,7 +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,15 +92,10 @@ void AssemblyBase::handleChildrenTransition() {
   if (commandsOutstanding <= 0) {
     switch (internalState) {
       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: {  
+      case STATE_OVERWRITE_HEALTH: {
         internalState = STATE_SINGLE_STEP;
         ReturnValue_t result = commandChildren(mode, submode);
         if (result == NEED_SECOND_STEP) {
@@ -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,15 +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) {
@@ -287,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);
-}

src/fsfw/devicehandlers/AssemblyBase.h

@@ -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_ */

src/fsfw/devicehandlers/FreshDeviceHandlerBase.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.

src/fsfw/events/Event.h

@@ -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_ */

src/fsfw/health/HasHealthIF.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;

src/fsfw/housekeeping.h

@@ -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_ */

src/fsfw/housekeeping/Dataset.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;
   }
 

src/fsfw/housekeeping/PeriodicHkHelper.cpp

@@ -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;
     }

src/fsfw/osal/freertos/Clock.cpp

@@ -5,7 +5,6 @@
 
 #include "FreeRTOS.h"
 #include "fsfw/globalfunctions/timevalOperations.h"
-#include "fsfw/serviceinterface/ServiceInterfacePrinter.h"
 #include "fsfw/osal/freertos/Timekeeper.h"
 #include "task.h"
 
@@ -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);
 }
 

src/fsfw/osal/freertos/Timekeeper.cpp

@@ -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,7 +33,3 @@ timeval Timekeeper::ticksToTimeval(TickType_t ticks) {
 }
 
 TickType_t Timekeeper::getTicks() { return xTaskGetTickCount(); }
-
-const timeval Timekeeper::getMonotonicClockOffset() const {
-	return monotonicClockOffset;
-}

src/fsfw/osal/freertos/Timekeeper.h

@@ -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_ */

src/fsfw/pus/Service11TelecommandScheduling.h

@@ -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 {

src/fsfw/serviceinterface/ServiceInterfacePrinter.cpp

@@ -53,17 +53,17 @@ void fsfwPrint(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
@@ -75,7 +75,7 @@ void fsfwPrint(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);
 

src/fsfw/subsystem/SubsystemBase.cpp

@@ -78,37 +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);
@@ -353,7 +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;
-}

src/fsfw/subsystem/SubsystemBase.h

@@ -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_ */

src/fsfw/tcdistribution/definitions.h

@@ -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

src/fsfw/thermal/TemperatureSensor.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(); }
 

src/fsfw/timemanager/Clock.h

@@ -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_ */

src/fsfw/tmstorage/TmStoreMessage.cpp

@@ -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(); }
 

src/fsfw/tmstorage/TmStoreMessage.h

@@ -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();

unittests/datapool/testDataset.cpp

@@ -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;

unittests/datapool/testSharedSet.cpp

@@ -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);