diff --git a/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp b/misc/archive/GyroL3GD20Handler.cpp
similarity index 94%
rename from src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp
rename to misc/archive/GyroL3GD20Handler.cpp
index c71f34ce..e876800d 100644
--- a/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.cpp
+++ b/misc/archive/GyroL3GD20Handler.cpp
@@ -8,7 +8,8 @@ GyroHandlerL3GD20H::GyroHandlerL3GD20H(object_id_t objectId, object_id_t deviceC
                                        CookieIF *comCookie, uint32_t transitionDelayMs)
     : DeviceHandlerBase(objectId, deviceCommunication, comCookie),
       transitionDelayMs(transitionDelayMs),
-      dataset(this) {}
+      sharedPool(DeviceHandlerBase::getObjectId()),
+      dataset(sharedPool) {}
 
 GyroHandlerL3GD20H::~GyroHandlerL3GD20H() {}
 
@@ -210,27 +211,27 @@ ReturnValue_t GyroHandlerL3GD20H::interpretDeviceReply(DeviceCommandId_t id,
       if (readSet.getReadResult() == returnvalue::OK) {
         if (std::abs(angVelocX) < this->absLimitX) {
           dataset.angVelocX = angVelocX;
-          dataset.angVelocX.setValid(true);
+          // dataset.angVelocX.setValid(true);
         } else {
-          dataset.angVelocX.setValid(false);
+          // dataset.angVelocX.setValid(false);
         }
 
         if (std::abs(angVelocY) < this->absLimitY) {
           dataset.angVelocY = angVelocY;
-          dataset.angVelocY.setValid(true);
+          // dataset.angVelocY.setValid(true);
         } else {
-          dataset.angVelocY.setValid(false);
+          // dataset.angVelocY.setValid(false);
         }
 
         if (std::abs(angVelocZ) < this->absLimitZ) {
           dataset.angVelocZ = angVelocZ;
-          dataset.angVelocZ.setValid(true);
+          // dataset.angVelocZ.setValid(true);
         } else {
-          dataset.angVelocZ.setValid(false);
+          // dataset.angVelocZ.setValid(false);
         }
 
         dataset.temperature = temperature;
-        dataset.temperature.setValid(true);
+        // dataset.temperature.setValid(true);
       }
       break;
     }
@@ -246,16 +247,19 @@ uint32_t GyroHandlerL3GD20H::getTransitionDelayMs(Mode_t from, Mode_t to) {
 
 void GyroHandlerL3GD20H::setToGoToNormalMode(bool enable) { this->goNormalModeImmediately = true; }
 
+// TODO
+/*
 ReturnValue_t GyroHandlerL3GD20H::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                                          LocalDataPoolManager &poolManager) {
+                                                          PeriodicHkGenerationHelper &hkGenHelper) {
   localDataPoolMap.emplace(l3gd20h::ANG_VELOC_X, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(l3gd20h::ANG_VELOC_Y, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(l3gd20h::ANG_VELOC_Z, new PoolEntry<float>({0.0}));
   localDataPoolMap.emplace(l3gd20h::TEMPERATURE, new PoolEntry<float>({0.0}));
-  poolManager.subscribeForRegularPeriodicPacket(
+  hkGenHelper.enableRegularPeriodicPacket(
       subdp::RegularHkPeriodicParams(dataset.getSid(), false, 10.0));
   return returnvalue::OK;
 }
+ */
 
 void GyroHandlerL3GD20H::fillCommandAndReplyMap() {
   insertInCommandAndReplyMap(l3gd20h::READ_REGS, 1, &dataset);
diff --git a/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.h b/misc/archive/GyroL3GD20Handler.h
similarity index 89%
rename from src/fsfw_hal/devicehandlers/GyroL3GD20Handler.h
rename to misc/archive/GyroL3GD20Handler.h
index 9897dc00..8a6f7d23 100644
--- a/src/fsfw_hal/devicehandlers/GyroL3GD20Handler.h
+++ b/misc/archive/GyroL3GD20Handler.h
@@ -1,9 +1,9 @@
 #ifndef MISSION_DEVICES_GYROL3GD20HANDLER_H_
 #define MISSION_DEVICES_GYROL3GD20HANDLER_H_
 
-#include <fsfw/devicehandlers/DeviceHandlerBase.h>
-#include <fsfw/globalfunctions/PeriodicOperationDivider.h>
-#include <fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.h>
+#include "fsfw/devicehandlers/DeviceHandlerBase.h"
+#include "fsfw/globalfunctions/PeriodicOperationDivider.h"
+#include "gyroL3gHelpers.h"
 
 /**
  * @brief 	Device Handler for the L3GD20H gyroscope sensor
@@ -51,11 +51,12 @@ class GyroHandlerL3GD20H : public DeviceHandlerBase {
   void fillCommandAndReplyMap() override;
   void modeChanged() override;
   virtual uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
-  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                        LocalDataPoolManager &poolManager) override;
+  // ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+  // PeriodicHkGenerationHelper &hkGenHelper) override;
 
  private:
   uint32_t transitionDelayMs = 0;
+    localpool::SharedPool sharedPool;
   GyroPrimaryDataset dataset;
 
   float absLimitX = l3gd20h::RANGE_DPS_00;
diff --git a/misc/archive/HasLocalDpIFManagerAttorney.cpp b/misc/archive/HasLocalDpIFManagerAttorney.cpp
new file mode 100644
index 00000000..097a0ec0
--- /dev/null
+++ b/misc/archive/HasLocalDpIFManagerAttorney.cpp
@@ -0,0 +1,13 @@
+#include "HasLocalDpIFManagerAttorney.h"
+
+#include "fsfw/datapool/LocalPoolObjectBase.h"
+#include "fsfw/housekeeping/GeneratesPeriodicHkIF.h"
+
+LocalPoolObjectBase* HasLocalDpIFManagerAttorney::getPoolObjectHandle(
+    PeriodicHkGenerationIF* clientIF, dp::lp_id_t localPoolId) {
+  return clientIF->getPoolObjectHandle(localPoolId);
+}
+
+object_id_t HasLocalDpIFManagerAttorney::getObjectId(PeriodicHkGenerationIF* clientIF) {
+  return clientIF->getObjectId();
+}
diff --git a/misc/archive/HasLocalDpIFManagerAttorney.h b/misc/archive/HasLocalDpIFManagerAttorney.h
new file mode 100644
index 00000000..ae19b8c1
--- /dev/null
+++ b/misc/archive/HasLocalDpIFManagerAttorney.h
@@ -0,0 +1,17 @@
+#pragma once
+#include <fsfw/housekeeping/PeriodicHkHelper.h>
+
+#include "fsfw/datapool/definitions.h"
+
+class PeriodicHkGenerationIF;
+class LocalPoolDataSetBase;
+class LocalPoolObjectBase;
+
+class HasLocalDpIFManagerAttorney {
+  static LocalPoolObjectBase* getPoolObjectHandle(PeriodicHkGenerationIF* clientIF,
+                                                  dp::id_t localPoolId);
+
+  static object_id_t getObjectId(PeriodicHkGenerationIF* clientIF);
+
+  friend class hk::PeriodicHelper;
+};
\ No newline at end of file
diff --git a/misc/archive/HasLocalDpIFUserAttorney.cpp b/misc/archive/HasLocalDpIFUserAttorney.cpp
new file mode 100644
index 00000000..619e415d
--- /dev/null
+++ b/misc/archive/HasLocalDpIFUserAttorney.cpp
@@ -0,0 +1 @@
+#include "HasLocalDpIFUserAttorney.h"
diff --git a/src/fsfw/datapoollocal/internal/HasLocalDpIFUserAttorney.h b/misc/archive/HasLocalDpIFUserAttorney.h
similarity index 73%
rename from src/fsfw/datapoollocal/internal/HasLocalDpIFUserAttorney.h
rename to misc/archive/HasLocalDpIFUserAttorney.h
index 72ea0a94..c668839f 100644
--- a/src/fsfw/datapoollocal/internal/HasLocalDpIFUserAttorney.h
+++ b/misc/archive/HasLocalDpIFUserAttorney.h
@@ -1,12 +1,12 @@
 #ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
 #define FSFW_DATAPOOLLOCAL_HASLOCALDPIFUSERATTORNEY_H_
 
-class HasLocalDataPoolIF;
+class PeriodicHkGenerationIF;
 class AccessPoolManagerIF;
 
 class HasLocalDpIFUserAttorney {
  private:
-  static AccessPoolManagerIF* getAccessorHandle(HasLocalDataPoolIF* clientIF);
+  // static AccessPoolManagerIF* getAccessorHandle(PeriodicHkGenerationIF* clientIF);
 
   friend class LocalPoolObjectBase;
   friend class LocalPoolDataSetBase;
diff --git a/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp b/misc/archive/MgmLIS3MDLHandler.cpp
similarity index 98%
rename from src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp
rename to misc/archive/MgmLIS3MDLHandler.cpp
index a66745e1..56f45bbe 100644
--- a/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.cpp
+++ b/misc/archive/MgmLIS3MDLHandler.cpp
@@ -273,7 +273,7 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons
       if (readHelper.getReadResult() == returnvalue::OK) {
         if (std::abs(mgmX) > absLimitX or std::abs(mgmY) > absLimitY or
             std::abs(mgmZ) > absLimitZ) {
-          dataset.fieldStrengths.setValid(false);
+          dataset.setIsValid = false;
         }
         if (std::abs(mgmX) < absLimitX) {
           dataset.fieldStrengths[0] = mgmX;
@@ -286,7 +286,7 @@ ReturnValue_t MgmLIS3MDLHandler::interpretDeviceReply(DeviceCommandId_t id, cons
         if (std::abs(mgmZ) < absLimitZ) {
           dataset.fieldStrengths[2] = mgmZ;
         }
-        dataset.fieldStrengths.setValid(true);
+        dataset.setIsValid = true;
       }
       break;
     }
@@ -415,13 +415,15 @@ uint32_t MgmLIS3MDLHandler::getTransitionDelayMs(Mode_t from, Mode_t to) { retur
 
 void MgmLIS3MDLHandler::modeChanged(void) { internalState = InternalState::STATE_NONE; }
 
+/*
 ReturnValue_t MgmLIS3MDLHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                                         LocalDataPoolManager &poolManager) {
+                                                         PeriodicHkGenerationHelper &poolManager) {
   localDataPoolMap.emplace(mgmLis3::FIELD_STRENGTHS, &mgmXYZ);
   localDataPoolMap.emplace(mgmLis3::TEMPERATURE_CELCIUS, &temperature);
-  poolManager.subscribeForRegularPeriodicPacket({dataset.getSid(), false, 10.0});
+  poolManager.setPeriodicFrequency(dataset.getSid(), 10'000);
   return returnvalue::OK;
 }
+ */
 
 void MgmLIS3MDLHandler::setAbsoluteLimits(float xLimit, float yLimit, float zLimit) {
   this->absLimitX = xLimit;
diff --git a/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h b/misc/archive/MgmLIS3MDLHandler.h
similarity index 95%
rename from src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
rename to misc/archive/MgmLIS3MDLHandler.h
index 78b3b38c..3dc75e9d 100644
--- a/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
+++ b/misc/archive/MgmLIS3MDLHandler.h
@@ -1,7 +1,7 @@
 #ifndef MISSION_DEVICES_MGMLIS3MDLHANDLER_H_
 #define MISSION_DEVICES_MGMLIS3MDLHANDLER_H_
 
-#include <fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h>
+#include "mgmLis3Helpers.h"
 
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #include "fsfw/globalfunctions/PeriodicOperationDivider.h"
@@ -63,8 +63,8 @@ class MgmLIS3MDLHandler : public DeviceHandlerBase {
   virtual ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
   void fillCommandAndReplyMap() override;
   void modeChanged(void) override;
-  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                        LocalDataPoolManager &poolManager) override;
+  // ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+  // PeriodicHkGenerationHelper &poolManager) override;
 
  private:
   mgmLis3::MgmPrimaryDataset dataset;
diff --git a/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp b/misc/archive/MgmRM3100Handler.cpp
similarity index 98%
rename from src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp
rename to misc/archive/MgmRM3100Handler.cpp
index c17e3abc..e4da857c 100644
--- a/src/fsfw_hal/devicehandlers/MgmRM3100Handler.cpp
+++ b/misc/archive/MgmRM3100Handler.cpp
@@ -9,7 +9,7 @@
 MgmRM3100Handler::MgmRM3100Handler(object_id_t objectId, object_id_t deviceCommunication,
                                    CookieIF *comCookie, uint32_t transitionDelay)
     : DeviceHandlerBase(objectId, deviceCommunication, comCookie),
-      primaryDataset(this),
+      primaryDataset(sharedPool),
       transitionDelay(transitionDelay) {}
 
 MgmRM3100Handler::~MgmRM3100Handler() {}
@@ -307,12 +307,15 @@ void MgmRM3100Handler::fillCommandAndReplyMap() {
 
 void MgmRM3100Handler::modeChanged() { internalState = InternalState::NONE; }
 
+// TODO: Fix
+/*
 ReturnValue_t MgmRM3100Handler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                                        LocalDataPoolManager &poolManager) {
+                                                        PeriodicHkGenerationHelper &poolManager) {
   localDataPoolMap.emplace(mgmRm3100::FIELD_STRENGTHS, &mgmXYZ);
-  poolManager.subscribeForRegularPeriodicPacket({primaryDataset.getSid(), false, 10.0});
+  poolManager.setPeriodicFrequency(primaryDataset.getSid(), 10'000);
   return returnvalue::OK;
 }
+ */
 
 uint32_t MgmRM3100Handler::getTransitionDelayMs(Mode_t from, Mode_t to) {
   return this->transitionDelay;
@@ -356,7 +359,7 @@ ReturnValue_t MgmRM3100Handler::handleDataReadout(const uint8_t *packet) {
     primaryDataset.fieldStrengths[0] = fieldStrengthX;
     primaryDataset.fieldStrengths[1] = fieldStrengthY;
     primaryDataset.fieldStrengths[2] = fieldStrengthZ;
-    primaryDataset.setValidity(true, true);
+    primaryDataset.valid = true;
   }
   return returnvalue::OK;
 }
diff --git a/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h b/misc/archive/MgmRM3100Handler.h
similarity index 94%
rename from src/fsfw_hal/devicehandlers/MgmRM3100Handler.h
rename to misc/archive/MgmRM3100Handler.h
index 1e56bc9d..c118bcd5 100644
--- a/src/fsfw_hal/devicehandlers/MgmRM3100Handler.h
+++ b/misc/archive/MgmRM3100Handler.h
@@ -1,7 +1,7 @@
 #ifndef MISSION_DEVICES_MGMRM3100HANDLER_H_
 #define MISSION_DEVICES_MGMRM3100HANDLER_H_
 
-#include <fsfw_hal/devicehandlers/devicedefinitions/mgmRm3100Helpers.h>
+#include "mgmRm3100Helpers.h"
 
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #include "fsfw/globalfunctions/PeriodicOperationDivider.h"
@@ -52,8 +52,8 @@ class MgmRM3100Handler : public DeviceHandlerBase {
   void fillCommandAndReplyMap() override;
   void modeChanged(void) override;
   virtual uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
-  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                        LocalDataPoolManager &poolManager) override;
+  // ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+  // PeriodicHkGenerationHelper &poolManager) override;
 
  private:
   enum class InternalState {
diff --git a/misc/archive/ProvidesDataPoolSubscriptionIF.h b/misc/archive/ProvidesDataPoolSubscriptionIF.h
new file mode 100644
index 00000000..25ea3918
--- /dev/null
+++ b/misc/archive/ProvidesDataPoolSubscriptionIF.h
@@ -0,0 +1,46 @@
+#ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
+#define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
+
+#include <fsfw/timemanager/clockDefinitions.h>
+
+#include <optional>
+
+#include "fsfw/housekeeping/AcceptsHkPacketsIF.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/ipc/messageQueueDefinitions.h"
+#include "fsfw/returnvalues/returnvalue.h"
+#include "localPoolDefinitions.h"
+
+namespace subdp {
+
+struct ParamsBase {
+  ParamsBase(sid_t sid, bool enableReporting, dur_millis_t collectionIntervalMs)
+      : sid(sid), enableReporting(enableReporting), collectionIntervalMs(collectionIntervalMs) {}
+
+  [[nodiscard]] bool isDiagnostics() const { return diagnostics; }
+
+  sid_t sid;
+  bool enableReporting;
+  dur_millis_t collectionIntervalMs;
+  MessageQueueId_t receiver = MessageQueueIF::NO_QUEUE;
+
+ protected:
+  bool diagnostics;
+};
+
+struct RegularHkPeriodicParams : public ParamsBase {
+  RegularHkPeriodicParams(sid_t sid, bool enableReporting, dur_millis_t collectionIntervalMs)
+      : ParamsBase(sid, enableReporting, collectionIntervalMs) {}
+};
+
+struct RegularHkUpdateParams : public ParamsBase {
+  RegularHkUpdateParams(sid_t sid, bool enableReporting) : ParamsBase(sid, enableReporting, 0) {}
+};
+
+struct DiagnosticsHkUpdateParams : public ParamsBase {
+  DiagnosticsHkUpdateParams(sid_t sid, bool enableReporting)
+      : ParamsBase(sid, enableReporting, 0) {}
+};
+}  // namespace subdp
+
+#endif /* FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_ */
diff --git a/src/fsfw/datapoollocal/SharedLocalDataSet.cpp b/misc/archive/SharedLocalDataset.cpp
similarity index 54%
rename from src/fsfw/datapoollocal/SharedLocalDataSet.cpp
rename to misc/archive/SharedLocalDataset.cpp
index 6d0b0b11..f3b9bf9f 100644
--- a/src/fsfw/datapoollocal/SharedLocalDataSet.cpp
+++ b/misc/archive/SharedLocalDataset.cpp
@@ -1,21 +1,23 @@
-#include "fsfw/datapoollocal/SharedLocalDataSet.h"
+#include "fsfw/datapool/SharedLocalDataset.h"
 
-SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, sid_t sid, const size_t maxSize)
-    : SystemObject(objectId), LocalPoolDataSetBase(sid, nullptr, maxSize), poolVarVector(maxSize) {
+SharedLocalDataset::SharedLocalDataset(object_id_t objectId, structure_id_t sid, const size_t maxSize)
+    : SystemObject(objectId), SharedDatasetBase(sid, nullptr, maxSize), poolVarVector(maxSize) {
   this->setContainer(poolVarVector.data());
   datasetLock = MutexFactory::instance()->createMutex();
 }
 
-SharedLocalDataSet::SharedLocalDataSet(object_id_t objectId, HasLocalDataPoolIF *owner,
+SharedLocalDataset::SharedLocalDataset(object_id_t objectId, localpool::SharedPool& sharedPool,
                                        uint32_t setId, const size_t maxSize)
     : SystemObject(objectId),
-      LocalPoolDataSetBase(owner, setId, nullptr, maxSize),
+      SharedDatasetBase(sharedPool, setId, nullptr, maxSize),
       poolVarVector(maxSize) {
   this->setContainer(poolVarVector.data());
   datasetLock = MutexFactory::instance()->createMutex();
 }
 
-ReturnValue_t SharedLocalDataSet::lockDataset(MutexIF::TimeoutType timeoutType,
+SharedLocalDataset::~SharedLocalDataset() { MutexFactory::instance()->deleteMutex(datasetLock); }
+
+ReturnValue_t SharedLocalDataset::lockDataset(MutexIF::TimeoutType timeoutType,
                                               dur_millis_t mutexTimeout) {
   if (datasetLock != nullptr) {
     return datasetLock->lockMutex(timeoutType, mutexTimeout);
@@ -23,9 +25,7 @@ ReturnValue_t SharedLocalDataSet::lockDataset(MutexIF::TimeoutType timeoutType,
   return returnvalue::FAILED;
 }
 
-SharedLocalDataSet::~SharedLocalDataSet() { MutexFactory::instance()->deleteMutex(datasetLock); }
-
-ReturnValue_t SharedLocalDataSet::unlockDataset() {
+ReturnValue_t SharedLocalDataset::unlockDataset() {
   if (datasetLock != nullptr) {
     return datasetLock->unlockMutex();
   }
diff --git a/misc/archive/SharedLocalDataset.h b/misc/archive/SharedLocalDataset.h
new file mode 100644
index 00000000..eefde6a3
--- /dev/null
+++ b/misc/archive/SharedLocalDataset.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <vector>
+
+#include "fsfw/datapool/SharedDataSetIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "SharedSetBase.h"
+#include "SharedPool.h"
+
+namespace datapool {
+
+ /**
+ * This local dataset variation can be used if the dataset is used concurrently across
+ * multiple threads. It provides a lock in addition to all other functionalities provided
+ * by the LocalPoolDataSetBase class.
+ *
+ * The user is completely responsible for locking and unlocking the dataset when using the
+ * shared dataset.
+ */
+class SharedLocalDataset : public SystemObject, public SharedSetBase, public SharedDataSetIF {
+ public:
+  SharedLocalDataset(object_id_t objectId, SharedPool& sharedPool, uint32_t setId,
+                     size_t maxSize);
+  SharedLocalDataset(object_id_t objectId, sid_t sid, size_t maxSize);
+
+  ~SharedLocalDataset() override;
+
+  ReturnValue_t lockDataset(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+                            dur_millis_t mutexTimeout = 20) override;
+  ReturnValue_t unlockDataset() override;
+
+ private:
+  MutexIF* datasetLock = nullptr;
+  std::vector<PoolVariableIF*> poolVarVector;
+};
+
+}
diff --git a/src/fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.cpp b/misc/archive/gyroL3gHelpers.cpp
similarity index 81%
rename from src/fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.cpp
rename to misc/archive/gyroL3gHelpers.cpp
index 13f00b10..28db7e9e 100644
--- a/src/fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.cpp
+++ b/misc/archive/gyroL3gHelpers.cpp
@@ -1,4 +1,4 @@
-#include <fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.h>
+#include "gyroL3gHelpers.h"
 
 float l3gd20h::ctrlReg4ToSensitivity(uint8_t reg) {
   bool fsH = reg & l3gd20h::SET_FS_1;
diff --git a/src/fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.h b/misc/archive/gyroL3gHelpers.h
similarity index 95%
rename from src/fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.h
rename to misc/archive/gyroL3gHelpers.h
index 0135a04c..06e052bf 100644
--- a/src/fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.h
+++ b/misc/archive/gyroL3gHelpers.h
@@ -1,8 +1,8 @@
 #ifndef MISSION_DEVICES_DEVICEDEFINITIONS_GYROL3GD20DEFINITIONS_H_
 #define MISSION_DEVICES_DEVICEDEFINITIONS_GYROL3GD20DEFINITIONS_H_
 
-#include <fsfw/datapoollocal/StaticLocalDataSet.h>
-#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include "fsfw/datapoollocal/StaticLocalDataSet.h"
+#include "fsfw/devicehandlers/DeviceHandlerIF.h"
 
 #include <cstdint>
 
@@ -124,8 +124,8 @@ class GyroPrimaryDataset : public StaticLocalDataSet<5> {
     setAllVariablesReadOnly();
   }
   /** Constructor  for the data creator */
-  GyroPrimaryDataset(HasLocalDataPoolIF* hkOwner)
-      : StaticLocalDataSet(hkOwner, l3gd20h::GYRO_DATASET_ID) {}
+  GyroPrimaryDataset(localpool::SharedPool& sharedPool)
+      : StaticLocalDataSet(sharedPool, l3gd20h::GYRO_DATASET_ID) {}
 
   /* Angular velocities in degrees per second (DPS) */
   lp_var_t<float> angVelocX = lp_var_t<float>(sid.objectId, l3gd20h::ANG_VELOC_X, this);
diff --git a/src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.cpp b/misc/archive/mgmLis3Helpers.cpp
similarity index 100%
rename from src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.cpp
rename to misc/archive/mgmLis3Helpers.cpp
diff --git a/src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h b/misc/archive/mgmLis3Helpers.h
similarity index 94%
rename from src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h
rename to misc/archive/mgmLis3Helpers.h
index 8d47a200..b78679cd 100644
--- a/src/fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h
+++ b/misc/archive/mgmLis3Helpers.h
@@ -1,9 +1,9 @@
 #ifndef MISSION_DEVICES_DEVICEDEFINITIONS_MGMLIS3HANDLERDEFS_H_
 #define MISSION_DEVICES_DEVICEDEFINITIONS_MGMLIS3HANDLERDEFS_H_
 
-#include <fsfw/datapoollocal/LocalPoolVariable.h>
-#include <fsfw/datapoollocal/StaticLocalDataSet.h>
-#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include "fsfw/datapoollocal/LocalPoolVariable.h"
+#include "fsfw/datapoollocal/StaticLocalDataSet.h"
+#include "fsfw/devicehandlers/DeviceHandlerIF.h"
 
 #include <cstdint>
 
@@ -169,11 +169,12 @@ static const uint8_t CTRL_REG5_DEFAULT = 0;
 
 static const uint32_t MGM_DATA_SET_ID = READ_CONFIG_AND_DATA;
 
-enum MgmPoolIds : lp_id_t { FIELD_STRENGTHS, TEMPERATURE_CELCIUS };
+enum MgmPoolIds : lp_id_t { FIELD_STRENGTHS = 0, TEMPERATURE_CELCIUS = 1, SET_IS_VALID = 2 };
 
 class MgmPrimaryDataset : public StaticLocalDataSet<4> {
  public:
-  MgmPrimaryDataset(HasLocalDataPoolIF* hkOwner) : StaticLocalDataSet(hkOwner, MGM_DATA_SET_ID) {}
+  MgmPrimaryDataset(localpool::SharedPool& sharedPool)
+      : StaticLocalDataSet(sharedPool, MGM_DATA_SET_ID) {}
 
   MgmPrimaryDataset(object_id_t mgmId) : StaticLocalDataSet(sid_t(mgmId, MGM_DATA_SET_ID)) {}
 
@@ -182,6 +183,7 @@ class MgmPrimaryDataset : public StaticLocalDataSet<4> {
    */
   lp_vec_t<float, 3> fieldStrengths = lp_vec_t<float, 3>(sid.objectId, FIELD_STRENGTHS, this);
   lp_var_t<float> temperature = lp_var_t<float>(sid.objectId, TEMPERATURE_CELCIUS, this);
+  lp_var_t<uint8_t> setIsValid = lp_var_t<uint8_t>(sid.objectId, SET_IS_VALID, this);
 };
 
 }  // namespace mgmLis3
diff --git a/src/fsfw_hal/devicehandlers/devicedefinitions/mgmRm3100Helpers.h b/misc/archive/mgmRm3100Helpers.h
similarity index 89%
rename from src/fsfw_hal/devicehandlers/devicedefinitions/mgmRm3100Helpers.h
rename to misc/archive/mgmRm3100Helpers.h
index 680bd13d..be29915c 100644
--- a/src/fsfw_hal/devicehandlers/devicedefinitions/mgmRm3100Helpers.h
+++ b/misc/archive/mgmRm3100Helpers.h
@@ -1,13 +1,13 @@
 #ifndef MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERRM3100DEFINITIONS_H_
 #define MISSION_DEVICES_DEVICEDEFINITIONS_MGMHANDLERRM3100DEFINITIONS_H_
 
-#include <fsfw/datapoollocal/LocalPoolVariable.h>
-#include <fsfw/datapoollocal/StaticLocalDataSet.h>
-#include <fsfw/devicehandlers/DeviceHandlerIF.h>
-#include <fsfw/serialize/SerialLinkedListAdapter.h>
-
 #include <cstdint>
 
+#include "fsfw/datapoollocal/LocalPoolVariable.h"
+#include "fsfw/datapoollocal/StaticLocalDataSet.h"
+#include "fsfw/devicehandlers/DeviceHandlerIF.h"
+#include "fsfw/serialize/SerialLinkedListAdapter.h"
+
 namespace mgmRm3100 {
 
 /* Actually 10, we round up a little bit */
@@ -101,11 +101,12 @@ class CycleCountCommand : public SerialLinkedListAdapter<SerializeIF> {
 
 static constexpr uint32_t MGM_DATASET_ID = READ_DATA;
 
-enum MgmPoolIds : lp_id_t { FIELD_STRENGTHS };
+enum MgmPoolIds : lp_id_t { FIELD_STRENGTHS = 0, VALID = 1 };
 
 class Rm3100PrimaryDataset : public StaticLocalDataSet<3> {
  public:
-  Rm3100PrimaryDataset(HasLocalDataPoolIF* hkOwner) : StaticLocalDataSet(hkOwner, MGM_DATASET_ID) {}
+  Rm3100PrimaryDataset(localpool::SharedPool& sharedPool)
+      : StaticLocalDataSet(sharedPool, MGM_DATASET_ID) {}
 
   Rm3100PrimaryDataset(object_id_t mgmId) : StaticLocalDataSet(sid_t(mgmId, MGM_DATASET_ID)) {}
 
@@ -113,6 +114,7 @@ class Rm3100PrimaryDataset : public StaticLocalDataSet<3> {
    * Field strenghts in uT
    */
   lp_vec_t<float, 3> fieldStrengths = lp_vec_t<float, 3>(sid.objectId, FIELD_STRENGTHS, this);
+  lp_var_t<uint8_t> valid = lp_var_t<uint8_t>(sid.objectId, VALID, this);
 };
 
 }  // namespace mgmRm3100
diff --git a/src/fsfw/CMakeLists.txt b/src/fsfw/CMakeLists.txt
index c8d4dc37..3710078d 100644
--- a/src/fsfw/CMakeLists.txt
+++ b/src/fsfw/CMakeLists.txt
@@ -7,7 +7,6 @@ add_subdirectory(cfdp)
 add_subdirectory(container)
 add_subdirectory(controller)
 add_subdirectory(datapool)
-add_subdirectory(datapoollocal)
 add_subdirectory(devicehandlers)
 add_subdirectory(events)
 add_subdirectory(fdir)
diff --git a/src/fsfw/controller/ExtendedControllerBase.cpp b/src/fsfw/controller/ExtendedControllerBase.cpp
index 63b21ba1..e03c7cba 100644
--- a/src/fsfw/controller/ExtendedControllerBase.cpp
+++ b/src/fsfw/controller/ExtendedControllerBase.cpp
@@ -2,7 +2,7 @@
 
 ExtendedControllerBase::ExtendedControllerBase(object_id_t objectId, size_t commandQueueDepth)
     : ControllerBase(objectId, commandQueueDepth),
-      poolManager(this, commandQueue),
+      hkHelper(this, commandQueue),
       actionHelper(this, commandQueue) {}
 
 ExtendedControllerBase::~ExtendedControllerBase() = default;
@@ -10,22 +10,18 @@ ExtendedControllerBase::~ExtendedControllerBase() = default;
 ReturnValue_t ExtendedControllerBase::executeAction(ActionId_t actionId,
                                                     MessageQueueId_t commandedBy,
                                                     const uint8_t *data, size_t size) {
-  /* Needs to be overriden and implemented by child class. */
+  // Needs to be overriden and implemented by child class.
   return returnvalue::OK;
 }
 
 object_id_t ExtendedControllerBase::getObjectId() const { return SystemObject::getObjectId(); }
 
-uint32_t ExtendedControllerBase::getPeriodicOperationFrequency() const {
-  return this->executingTask->getPeriodMs();
-}
-
 ReturnValue_t ExtendedControllerBase::handleCommandMessage(CommandMessage *message) {
   ReturnValue_t result = actionHelper.handleActionMessage(message);
   if (result == returnvalue::OK) {
     return result;
   }
-  return poolManager.handleHousekeepingMessage(message);
+  return hkHelper.handleHousekeepingMessage(message);
 }
 
 void ExtendedControllerBase::handleQueue() {
@@ -48,7 +44,7 @@ void ExtendedControllerBase::handleQueue() {
       continue;
     }
 
-    result = poolManager.handleHousekeepingMessage(&command);
+    result = hkHelper.handleHousekeepingMessage(&command);
     if (result == returnvalue::OK) {
       continue;
     }
@@ -72,22 +68,18 @@ ReturnValue_t ExtendedControllerBase::initialize() {
     return result;
   }
 
-  return poolManager.initialize(commandQueue);
-}
-
-ReturnValue_t ExtendedControllerBase::initializeAfterTaskCreation() {
-  return poolManager.initializeAfterTaskCreation();
+  return hkHelper.initialize(commandQueue);
 }
 
 ReturnValue_t ExtendedControllerBase::performOperation(uint8_t opCode) {
   handleQueue();
   performControlOperation(opCode);
-  /* We do this after performing control operation because variables will be set changed
-  in this function. */
-  poolManager.performHkOperation();
+  // We do this after performing control operation because variables will be set changed
+  // in this function.
+  hkHelper.performHkOperation();
   return returnvalue::OK;
 }
 
 MessageQueueId_t ExtendedControllerBase::getCommandQueue() const { return commandQueue->getId(); }
 
-LocalDataPoolManager *ExtendedControllerBase::getHkManagerHandle() { return &poolManager; }
+datapool::SharedPool *ExtendedControllerBase::getOptionalSharedPool() { return nullptr; }
\ No newline at end of file
diff --git a/src/fsfw/controller/ExtendedControllerBase.h b/src/fsfw/controller/ExtendedControllerBase.h
index 409f8e71..47824ea9 100644
--- a/src/fsfw/controller/ExtendedControllerBase.h
+++ b/src/fsfw/controller/ExtendedControllerBase.h
@@ -1,10 +1,11 @@
 #ifndef FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_
 #define FSFW_CONTROLLER_EXTENDEDCONTROLLERBASE_H_
 
+#include <fsfw/housekeeping/GeneratesPeriodicHkIF.h>
+
 #include "ControllerBase.h"
 #include "fsfw/action.h"
-#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
-#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+#include "fsfw/housekeeping/PeriodicHkHelper.h"
 
 /**
  * @brief   Extends the basic ControllerBase with commonly used components
@@ -15,9 +16,9 @@
  */
 class ExtendedControllerBase : public ControllerBase,
                                public HasActionsIF,
-                               public HasLocalDataPoolIF {
+                               public hk::GeneratesPeriodicHkIF {
  public:
-  ExtendedControllerBase(object_id_t objectId, size_t commandQueueDepth = 3);
+  explicit ExtendedControllerBase(object_id_t objectId, size_t commandQueueDepth = 3);
   ~ExtendedControllerBase() override;
 
   /* SystemObjectIF overrides */
@@ -27,12 +28,18 @@ class ExtendedControllerBase : public ControllerBase,
 
   /* ExecutableObjectIF overrides */
   ReturnValue_t performOperation(uint8_t opCode) override;
-  ReturnValue_t initializeAfterTaskCreation() override;
 
  protected:
-  LocalDataPoolManager poolManager;
+  hk::PeriodicHelper hkHelper;
   ActionHelper actionHelper;
 
+  // Periodic HK methods, default method assumes that no shared pool is required.
+  virtual datapool::SharedPool* getOptionalSharedPool() override;
+
+  // Periodic HK abstract methods.
+  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
    * not health, mode, action or housekeeping messages.
@@ -49,18 +56,12 @@ class ExtendedControllerBase : public ControllerBase,
   // Handle the four messages mentioned above
   void handleQueue() override;
 
-  /* HasActionsIF overrides */
+  // HasActionsIF overrides
   ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                               const uint8_t* data, size_t size) override;
 
-  /* HasLocalDatapoolIF overrides */
-  LocalDataPoolManager* getHkManagerHandle() override;
+  // HasLocalDatapoolIF overrides
   [[nodiscard]] object_id_t getObjectId() const override;
-  [[nodiscard]] uint32_t getPeriodicOperationFrequency() const override;
-
-  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                        LocalDataPoolManager& poolManager) override = 0;
-  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
 
   // Mode abstract functions
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
diff --git a/src/fsfw/datapool.h b/src/fsfw/datapool.h
new file mode 100644
index 00000000..632f95e5
--- /dev/null
+++ b/src/fsfw/datapool.h
@@ -0,0 +1,11 @@
+#ifndef FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_
+#define FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_
+
+// Collected related headers
+#include "fsfw/datapool/LocalPoolVector.h"
+#include "fsfw/datapool/PoolVariable.h"
+#include "fsfw/datapool/SharedPool.h"
+#include "fsfw/datapool/SharedSet.h"
+#include "fsfw/datapool/StaticSharedSet.h"
+
+#endif /* FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_ */
diff --git a/src/fsfw/datapool/CMakeLists.txt b/src/fsfw/datapool/CMakeLists.txt
index b2ac592c..d82997c7 100644
--- a/src/fsfw/datapool/CMakeLists.txt
+++ b/src/fsfw/datapool/CMakeLists.txt
@@ -1 +1,6 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE PoolDataSetBase.cpp PoolEntry.cpp)
+target_sources(
+  ${LIB_FSFW_NAME}
+  PRIVATE PoolDataSetBase.cpp PoolEntry.cpp SharedPool.cpp SharedSet.cpp
+          SharedSetBase.cpp LocalPoolObjectBase.cpp)
+
+add_subdirectory(internal)
diff --git a/src/fsfw/datapoollocal/LocalPoolObjectBase.cpp b/src/fsfw/datapool/LocalPoolObjectBase.cpp
similarity index 54%
rename from src/fsfw/datapoollocal/LocalPoolObjectBase.cpp
rename to src/fsfw/datapool/LocalPoolObjectBase.cpp
index b31a9be2..e035a6cc 100644
--- a/src/fsfw/datapoollocal/LocalPoolObjectBase.cpp
+++ b/src/fsfw/datapool/LocalPoolObjectBase.cpp
@@ -1,37 +1,26 @@
-#include "fsfw/datapoollocal/LocalPoolObjectBase.h"
+#include "fsfw/datapool/LocalPoolObjectBase.h"
 
-#include "fsfw/datapoollocal/AccessLocalPoolF.h"
-#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
-#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+#include "fsfw/housekeeping/PeriodicHkHelper.h"
 #include "fsfw/objectmanager/ObjectManager.h"
-#include "internal/HasLocalDpIFUserAttorney.h"
 
-LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
-                                         DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
-    : localPoolId(poolId), readWriteMode(setReadWriteMode) {
+using namespace dp;
+PoolObjectBase::PoolObjectBase(SharedPool& sharedPool, dp::id_t poolId, DataSetIF* dataSet,
+                               pool_rwm_t setReadWriteMode)
+    : localPoolId(poolId), readWriteMode(setReadWriteMode), sharedPool(&sharedPool) {
   if (poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::warning << "LocalPoolVar<T>::LocalPoolVar: 0 passed as pool ID, "
                  << "which is the NO_PARAMETER value!" << std::endl;
 #endif
   }
-  if (hkOwner == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "LocalPoolVar<T>::LocalPoolVar: The supplied pool " << "owner is a invalid!"
-               << std::endl;
-#endif
-    return;
-  }
-  AccessPoolManagerIF* poolManAccessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
-  hkManager = poolManAccessor->getPoolManagerHandle();
 
   if (dataSet != nullptr) {
     dataSet->registerVariable(this);
   }
 }
 
-LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF* dataSet,
-                                         pool_rwm_t setReadWriteMode)
+PoolObjectBase::PoolObjectBase(object_id_t poolOwner, id_t poolId, DataSetIF* dataSet,
+                               pool_rwm_t setReadWriteMode)
     : localPoolId(poolId), readWriteMode(setReadWriteMode) {
   if (poolId == PoolVariableIF::NO_PARAMETER) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -44,7 +33,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
         "which is the NO_PARAMETER value!\n");
 #endif
   }
-  HasLocalDataPoolIF* hkOwner = ObjectManager::instance()->get<HasLocalDataPoolIF>(poolOwner);
+  auto* hkOwner = ObjectManager::instance()->get<hk::GeneratesPeriodicHkIF>(poolOwner);
   if (hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "LocalPoolVariable: The supplied pool owner 0x" << std::hex << poolOwner
@@ -58,37 +47,25 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
 #endif
     return;
   }
-
-  AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
-  if (accessor != nullptr) {
-    hkManager = accessor->getPoolManagerHandle();
-  }
+  sharedPool = hkOwner->getOptionalSharedPool();
 
   if (dataSet != nullptr) {
     dataSet->registerVariable(this);
   }
 }
 
-pool_rwm_t LocalPoolObjectBase::getReadWriteMode() const { return readWriteMode; }
+pool_rwm_t PoolObjectBase ::getReadWriteMode() const { return readWriteMode; }
 
-bool LocalPoolObjectBase::isValid() const { return valid; }
+id_t PoolObjectBase ::getDataPoolId() const { return localPoolId; }
 
-void LocalPoolObjectBase::setValid(bool valid) { this->valid = valid; }
+void PoolObjectBase::setDataPoolId(id_t poolId) { this->localPoolId = poolId; }
 
-lp_id_t LocalPoolObjectBase::getDataPoolId() const { return localPoolId; }
-
-void LocalPoolObjectBase::setDataPoolId(lp_id_t poolId) { this->localPoolId = poolId; }
-
-void LocalPoolObjectBase::setChanged(bool changed) { this->changed = changed; }
-
-bool LocalPoolObjectBase::hasChanged() const { return changed; }
-
-void LocalPoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {
+void PoolObjectBase::setReadWriteMode(pool_rwm_t newReadWriteMode) {
   this->readWriteMode = newReadWriteMode;
 }
 
-void LocalPoolObjectBase::reportReadCommitError(const char* variableType, ReturnValue_t error,
-                                                bool read, object_id_t objectId, lp_id_t lpId) {
+void PoolObjectBase::reportReadCommitError(const char* variableType, ReturnValue_t error, bool read,
+                                           object_id_t objectId, id_t lpId) {
 #if FSFW_DISABLE_PRINTOUT == 0
   const char* variablePrintout = variableType;
   if (variablePrintout == nullptr) {
@@ -102,9 +79,9 @@ void LocalPoolObjectBase::reportReadCommitError(const char* variableType, Return
   }
 
   const char* errMsg = nullptr;
-  if (error == localpool::POOL_ENTRY_NOT_FOUND) {
+  if (error == POOL_ENTRY_NOT_FOUND) {
     errMsg = "Pool entry not found";
-  } else if (error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
+  } else if (error == POOL_ENTRY_TYPE_CONFLICT) {
     errMsg = "Pool entry type conflict";
   } else if (error == PoolVariableIF::INVALID_READ_WRITE_MODE) {
     errMsg = "Pool variable wrong read-write mode";
diff --git a/src/fsfw/datapool/LocalPoolObjectBase.h b/src/fsfw/datapool/LocalPoolObjectBase.h
new file mode 100644
index 00000000..e50a429f
--- /dev/null
+++ b/src/fsfw/datapool/LocalPoolObjectBase.h
@@ -0,0 +1,50 @@
+#pragma once
+
+#include "SharedPool.h"
+#include "fsfw/datapool/PoolVariableIF.h"
+#include "fsfw/datapool/definitions.h"
+#include "fsfw/objectmanager/SystemObjectIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
+
+class DataSetIF;
+
+namespace datapool {
+/**
+ * @brief 	This class serves as a non-template base for pool objects like pool variables
+ * 			or pool vectors.
+ */
+class PoolObjectBase : public PoolVariableIF {
+ public:
+  PoolObjectBase(dp::SharedPool& sharedPool, dp::id_t poolId, DataSetIF* dataSet,
+                 pool_rwm_t setReadWriteMode);
+
+  PoolObjectBase(object_id_t poolOwner, dp::id_t poolId, DataSetIF* dataSet = nullptr,
+                 pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+
+  void setReadWriteMode(pool_rwm_t newReadWriteMode) override;
+  [[nodiscard]] pool_rwm_t getReadWriteMode() const override;
+
+  [[nodiscard]] dp::id_t getDataPoolId() const override;
+  void setDataPoolId(dp::id_t poolId);
+
+ protected:
+  /**
+   * @brief   To access the correct data pool entry on read and commit calls,
+   *          the data pool id is stored.
+   */
+  uint32_t localPoolId = PoolVariableIF::NO_PARAMETER;
+
+  /**
+   * @brief   The information whether the class is read-write or
+   *          read-only is stored here.
+   */
+  ReadWriteMode_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
+
+  //! @brief  Pointer to the class which manages the HK pool.
+  dp::SharedPool* sharedPool = nullptr;
+
+  void reportReadCommitError(const char* variableType, ReturnValue_t error, bool read,
+                             object_id_t objectId, dp::id_t lpId);
+};
+
+}  // namespace datapool
\ No newline at end of file
diff --git a/src/fsfw/datapoollocal/LocalPoolVector.h b/src/fsfw/datapool/LocalPoolVector.h
similarity index 53%
rename from src/fsfw/datapoollocal/LocalPoolVector.h
rename to src/fsfw/datapool/LocalPoolVector.h
index ff5943aa..aed1731c 100644
--- a/src/fsfw/datapoollocal/LocalPoolVector.h
+++ b/src/fsfw/datapool/LocalPoolVector.h
@@ -1,14 +1,15 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
-#define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
+#pragma once
+
+#include <fsfw/ipc/MutexGuard.h>
 
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolEntry.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../datapoollocal/LocalDataPoolManager.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterface.h"
 #include "LocalPoolObjectBase.h"
-#include "internal/LocalDpManagerAttorney.h"
+#include "fsfw/datapool/DataSetIF.h"
+#include "fsfw/datapool/PoolEntry.h"
+#include "fsfw/datapool/PoolVariableIF.h"
+#include "fsfw/serialize/SerializeAdapter.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+
+namespace datapool {
 
 /**
  * @brief	This is the access class for array-type data pool entries.
@@ -24,16 +25,16 @@
  * @tparam	T
  * This template parameter specifies the data type of an array entry. Currently,
  * all plain data types are supported, but in principle any type is possible.
- * @tparam  vector_size
+ * @tparam  N
  * This template parameter specifies the vector size of this entry. Using a
  * template parameter for this is not perfect, but avoids
  * dynamic memory allocation.
  * @ingroup data_pool
  */
-template <typename T, uint16_t vectorSize>
-class LocalPoolVector : public LocalPoolObjectBase {
+template <typename T, size_t N>
+class PoolVector : public PoolObjectBase {
  public:
-  LocalPoolVector() = delete;
+  PoolVector() = delete;
   /**
    * This constructor is used by the data creators to have pool variable
    * instances which can also be stored in datasets.
@@ -47,8 +48,9 @@ class LocalPoolVector : public LocalPoolObjectBase {
    * @param dataSet The data set in which the variable shall register itself.
    * If nullptr, the variable is not registered.
    */
-  LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet = nullptr,
-                  pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+  PoolVector(SharedPool& sharedPool, id_t poolId, DataSetIF* dataSet = nullptr,
+             pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE)
+      : PoolObjectBase(sharedPool, poolId, dataSet, setReadWriteMode) {}
 
   /**
    * This constructor is used by data users like controllers to have
@@ -57,15 +59,15 @@ class LocalPoolVector : public LocalPoolObjectBase {
    * It does not fetch the current value from the data pool. This is performed
    * by the read() operation (which is not thread-safe).
    * Datasets can be used to access local pool entires in a thread-safe way.
+   * @param poolOwner Owner of the shared pool.
    * @param poolId ID of the local pool entry.
-   * @param hkOwner Pointer of the owner. This will generally be the calling
-   * class itself which passes "this".
    * @param setReadWriteMode Specify the read-write mode of the pool variable.
    * @param dataSet The data set in which the variable shall register itself.
    * If nullptr, the variable is not registered.
    */
-  LocalPoolVector(object_id_t poolOwner, lp_id_t poolId, DataSetIF* dataSet = nullptr,
-                  pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+  PoolVector(object_id_t poolOwner, id_t poolId, DataSetIF* dataSet = nullptr,
+             pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE)
+      : PoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
   /**
    * Variation which takes the unique global identifier of a local pool
    * vector.
@@ -73,8 +75,10 @@ class LocalPoolVector : public LocalPoolObjectBase {
    * @param dataSet
    * @param setReadWriteMode
    */
-  LocalPoolVector(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
-                  pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+  PoolVector(g_id_t globalPoolId, DataSetIF* dataSet = nullptr,
+             pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE)
+      : PoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet, setReadWriteMode) {
+  }
 
   /**
    * @brief	This is the local copy of the data pool entry.
@@ -82,27 +86,80 @@ class LocalPoolVector : public LocalPoolObjectBase {
    * The user can work on this attribute just like he would on a local
    * array of this type.
    */
-  T value[vectorSize] = {};
+  T value[N] = {};
   /**
    * @brief	The classes destructor is empty.
    * @details	If commit() was not called, the local value is
    * 			discarded and not written back to the data pool.
    */
-  ~LocalPoolVector() {};
+  ~PoolVector() override {};
   /**
    * @brief	The operation returns the number of array entries
    * 			in this variable.
    */
-  uint8_t getSize() { return vectorSize; }
+  size_t getSize() { return N; }
 
-  T& operator[](size_t i);
-  const T& operator[](size_t i) const;
+  T& operator[](size_t i) {
+    if (i < N) {
+      return value[i];
+    }
+    // If this happens, I have to set some value. I consider this
+    // a configuration error, but I wont exit here.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "PoolVector: Invalid index. Setting or returning"
+                    " last value!"
+                 << std::endl;
+#else
+    sif::printWarning(
+        "PoolVector: Invalid index. Setting or returning"
+        " last value!\n");
+#endif
+    return value[N - 1];
+  }
+  const T& operator[](size_t i) const {
+    if (i < N) {
+      return value[i];
+    }
+    // If this happens, I have to set some value. I consider this
+    // a configuration error, but I wont exit here.
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "PoolVector: Invalid index. Setting or returning"
+                    " last value!"
+                 << std::endl;
+#else
+    sif::printWarning(
+        "PoolVector: Invalid index. Setting or returning"
+        " last value!\n");
+#endif
+    return value[N - 1];
+  }
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, const size_t maxSize,
-                          SerializeIF::Endianness streamEndiannes) const override;
-  size_t getSerializedSize() const override;
+                          SerializeIF::Endianness streamEndianness) const override {
+    ReturnValue_t result = returnvalue::FAILED;
+    for (uint16_t i = 0; i < N; i++) {
+      result = SerializeAdapter::serialize(&(value[i]), buffer, size, maxSize, streamEndianness);
+      if (result != returnvalue::OK) {
+        break;
+      }
+    }
+    return result;
+  }
+
+  [[nodiscard]] size_t getSerializedSize() const override {
+    return N * SerializeAdapter::getSerializedSize(value);
+  }
   ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                            SerializeIF::Endianness streamEndianness) override;
+                            SerializeIF::Endianness streamEndianness) override {
+    ReturnValue_t result = returnvalue::FAILED;
+    for (uint16_t i = 0; i < N; i++) {
+      result = SerializeAdapter::deSerialize(&(value[i]), buffer, size, streamEndianness);
+      if (result != returnvalue::OK) {
+        break;
+      }
+    }
+    return result;
+  }
 
   /**
    * @brief	This is a call to read the array's values
@@ -118,7 +175,10 @@ class LocalPoolVector : public LocalPoolObjectBase {
    * at once to avoid the overhead of unnecessary lock und unlock operations.
    */
   ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                     uint32_t timeoutMs = 20) override;
+                     uint32_t timeoutMs = 20) override {
+    MutexGuard mg(sharedPool->getPoolMutex(), timeoutType, timeoutMs);
+    return readWithoutLock();
+  }
 
   /**
    * @brief	The commit call copies the array values back to the data pool.
@@ -129,15 +189,11 @@ class LocalPoolVector : public LocalPoolObjectBase {
    * It is recommended to use DataSets to read and commit multiple variables
    * at once to avoid the overhead of unnecessary lock und unlock operations.
    */
-  ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                       uint32_t timeoutMs = 20) override;
-
-  /**
-   * @brief	This commit call also sets the validity of the pool entry.
-   * @details
-   */
-  ReturnValue_t commit(bool valid, MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                       uint32_t timeoutMs = 20);
+  ReturnValue_t commit(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) override {
+    MutexGuard mg(sharedPool->getPoolMutex(), timeoutType, timeoutMs);
+    return commitWithoutLock();
+  }
+  ReturnValue_t commit() { return commit(MutexIF::TimeoutType::WAITING, 20); }
 
  protected:
   /**
@@ -148,7 +204,22 @@ class LocalPoolVector : public LocalPoolObjectBase {
    * of consecutive lock und unlock operations.
    * Declared protected to discourage free public usage.
    */
-  ReturnValue_t readWithoutLock() override;
+  ReturnValue_t readWithoutLock() override {
+    if (readWriteMode == pool_rwm_t::VAR_WRITE) {
+      return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
+
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = sharedPool->fetchPoolEntry(localPoolId, &poolEntry);
+    memset(this->value, 0, N * sizeof(T));
+
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
+    return returnvalue::OK;
+  }
+
   /**
    * @brief	Like #commit, but without a lock protection of the global pool.
    * @details
@@ -157,19 +228,36 @@ class LocalPoolVector : public LocalPoolObjectBase {
    * of consecutive lock und unlock operations.
    * Declared protected to discourage free public usage.
    */
-  ReturnValue_t commitWithoutLock() override;
+  ReturnValue_t commitWithoutLock() override {
+    if (readWriteMode == pool_rwm_t::VAR_READ) {
+      return PoolVariableIF::INVALID_READ_WRITE_MODE;
+    }
+    PoolEntry<T>* poolEntry = nullptr;
+    ReturnValue_t result = sharedPool->fetchPoolEntry(localPoolId, &poolEntry);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
+    return returnvalue::OK;
+  }
 
  private:
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-  // std::ostream is the type for object std::cout
-  template <typename U, uint16_t otherSize>
-  friend std::ostream& operator<<(std::ostream& out, const LocalPoolVector<U, otherSize>& var);
+  std::ostream& operator<<(std::ostream& out, const PoolVector<T, N>& var) {
+    out << "Vector: [";
+    for (int i = 0; i < N; i++) {
+      out << var.value[i];
+      if (i < N - 1) {
+        out << ", ";
+      }
+    }
+    out << "]";
+    return out;
+  }
 #endif
 };
 
-#include "LocalPoolVector.tpp"
+template <typename T, size_t N>
+using vec_t = PoolVector<T, N>;
 
-template <typename T, uint16_t vectorSize>
-using lp_vec_t = LocalPoolVector<T, vectorSize>;
-
-#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_ */
+}  // namespace datapool
diff --git a/src/fsfw/datapool/LocalPoolVector.tpp b/src/fsfw/datapool/LocalPoolVector.tpp
new file mode 100644
index 00000000..e69de29b
diff --git a/src/fsfw/datapoollocal/MarkChangedIF.h b/src/fsfw/datapool/MarkChangedIF.h
similarity index 100%
rename from src/fsfw/datapoollocal/MarkChangedIF.h
rename to src/fsfw/datapool/MarkChangedIF.h
diff --git a/src/fsfw/datapool/PoolDataSetBase.cpp b/src/fsfw/datapool/PoolDataSetBase.cpp
index 0df21d2a..2996a496 100644
--- a/src/fsfw/datapool/PoolDataSetBase.cpp
+++ b/src/fsfw/datapool/PoolDataSetBase.cpp
@@ -82,19 +82,19 @@ uint16_t PoolDataSetBase::getFillCount() const { return fillCount; }
 ReturnValue_t PoolDataSetBase::readVariable(uint16_t count) {
   ReturnValue_t result = returnvalue::OK;
   if (registeredVariables[count] == nullptr) {
-    /* Configuration error. */
+    // Configuration error.
     return returnvalue::FAILED;
   }
 
-  /* These checks are often performed by the respective variable implementation too, but I guess
-  a double check does not hurt. */
+  // These checks are often performed by the respective variable implementation too, but I guess
+  // a double check does not hurt.
   if (registeredVariables[count]->getReadWriteMode() != PoolVariableIF::VAR_WRITE and
       registeredVariables[count]->getDataPoolId() != PoolVariableIF::NO_PARAMETER) {
     if (protectEveryReadCommitCall) {
       result =
           registeredVariables[count]->read(timeoutTypeForSingleVars, mutexTimeoutForSingleVars);
     } else {
-      /* The readWithoutLock function is protected, so we use the attorney here */
+      // The readWithoutLock function is protected, so we use the attorney here
       result = ReadCommitIFAttorney::readWithoutLock(registeredVariables[count]);
     }
 
diff --git a/src/fsfw/datapool/PoolDataSetBase.h b/src/fsfw/datapool/PoolDataSetBase.h
index 621dd8cc..b7da7d7d 100644
--- a/src/fsfw/datapool/PoolDataSetBase.h
+++ b/src/fsfw/datapool/PoolDataSetBase.h
@@ -1,11 +1,14 @@
-#ifndef FSFW_DATAPOOL_POOLDATASETBASE_H_
-#define FSFW_DATAPOOL_POOLDATASETBASE_H_
+#pragma once
 
 #include "PoolDataSetIF.h"
 #include "PoolVariableIF.h"
 #include "fsfw/ipc/MutexIF.h"
 #include "fsfw/serialize/SerializeIF.h"
 
+namespace datapool {
+class SharedSetBase;
+}
+
 /**
  * @brief	The DataSetBase class manages a set of locally checked out variables.
  * @details
@@ -30,6 +33,8 @@
  * @ingroup data_pool
  */
 class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
+  friend class datapool::SharedSetBase;
+
  public:
   /**
    * @brief	Creates an empty dataset. Use registerVariable or
@@ -99,24 +104,23 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
    * thread-safety. Default implementation is empty
    * @return Always returns -@c returnvalue::OK
    */
-  virtual ReturnValue_t lockDataPool(
-      MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-      uint32_t timeoutMs = 20) override;
+  ReturnValue_t lockDataPool(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+                             uint32_t timeoutMs = 20) override;
   /**
    * Provides the means to unlock the underlying data structure to ensure
    * thread-safety. Default implementation is empty
    * @return Always returns -@c returnvalue::OK
    */
-  virtual ReturnValue_t unlockDataPool() override;
+  ReturnValue_t unlockDataPool() override;
 
-  virtual uint16_t getFillCount() const override;
+  [[nodiscard]] uint16_t getFillCount() const override;
 
   /* SerializeIF implementations */
-  virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size, const size_t maxSize,
-                                  SerializeIF::Endianness streamEndianness) const override;
-  virtual size_t getSerializedSize() const override;
-  virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                                    SerializeIF::Endianness streamEndianness) override;
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, const size_t maxSize,
+                          SerializeIF::Endianness streamEndianness) const override;
+  [[nodiscard]] size_t getSerializedSize() const override;
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            SerializeIF::Endianness streamEndianness) override;
 
   /**
    * Can be used to individually protect every read and commit call.
@@ -168,6 +172,4 @@ class PoolDataSetBase : public PoolDataSetIF, public SerializeIF {
       MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING, uint32_t timeoutMs = 20);
   ReturnValue_t handleUnreadDatasetCommit(
       MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING, uint32_t timeoutMs = 20);
-};
-
-#endif /* FSFW_DATAPOOL_POOLDATASETBASE_H_ */
+};
\ No newline at end of file
diff --git a/src/fsfw/datapool/PoolDataSetIF.h b/src/fsfw/datapool/PoolDataSetIF.h
index 33705c52..3f34bc90 100644
--- a/src/fsfw/datapool/PoolDataSetIF.h
+++ b/src/fsfw/datapool/PoolDataSetIF.h
@@ -10,7 +10,7 @@
  */
 class PoolDataSetIF : virtual public DataSetIF, virtual public ReadCommitIF {
  public:
-  virtual ~PoolDataSetIF() {};
+  ~PoolDataSetIF() override = default;
 
   /**
    * @brief   Most underlying data structures will have a pool like structure
@@ -18,17 +18,13 @@ class PoolDataSetIF : virtual public DataSetIF, virtual public ReadCommitIF {
    *          thread-safety
    * @return Lock operation result
    */
-  virtual ReturnValue_t lockDataPool(
-      MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-      uint32_t timeoutMs = 20) = 0;
+  virtual ReturnValue_t lockDataPool(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) = 0;
 
   /**
    * @brief   Unlock call corresponding to the lock call.
    * @return Unlock operation result
    */
   virtual ReturnValue_t unlockDataPool() = 0;
-
-  virtual bool isValid() const = 0;
 };
 
 #endif /* FSFW_DATAPOOL_POOLDATASETIF_H_ */
diff --git a/src/fsfw/datapool/PoolEntry.cpp b/src/fsfw/datapool/PoolEntry.cpp
index 9138a705..85e265bf 100644
--- a/src/fsfw/datapool/PoolEntry.cpp
+++ b/src/fsfw/datapool/PoolEntry.cpp
@@ -52,16 +52,6 @@ void* PoolEntry<T>::getRawData() {
   return this->address;
 }
 
-template <typename T>
-void PoolEntry<T>::setValid(bool isValid) {
-  this->valid = isValid;
-}
-
-template <typename T>
-bool PoolEntry<T>::getValid() {
-  return valid;
-}
-
 template <typename T>
 void PoolEntry<T>::print() {
   const char* validString = nullptr;
diff --git a/src/fsfw/datapool/PoolEntry.h b/src/fsfw/datapool/PoolEntry.h
index 4010f78d..2c4cd2e1 100644
--- a/src/fsfw/datapool/PoolEntry.h
+++ b/src/fsfw/datapool/PoolEntry.h
@@ -104,16 +104,7 @@ class PoolEntry : public PoolEntryIF {
    * @brief	This operation returns a the address pointer casted to void*.
    */
   void* getRawData();
-  /**
-   * @brief	This method allows to set the valid information
-   * 			of the pool entry.
-   */
-  void setValid(bool isValid);
-  /**
-   * @brief	This method allows to get the valid information
-   * 			of the pool entry.
-   */
-  bool getValid();
+
   /**
    * @brief	This is a debug method that prints all values and the valid
    * 			information to the screen. It prints all array entries in a row.
diff --git a/src/fsfw/datapool/PoolEntryIF.h b/src/fsfw/datapool/PoolEntryIF.h
index 99fd8024..affe68f1 100644
--- a/src/fsfw/datapool/PoolEntryIF.h
+++ b/src/fsfw/datapool/PoolEntryIF.h
@@ -39,14 +39,7 @@ class PoolEntryIF {
    * @brief	This operation returns a the address pointer casted to void*.
    */
   virtual void* getRawData() = 0;
-  /**
-   * @brief	This method allows to set the valid information of the pool entry.
-   */
-  virtual void setValid(bool isValid) = 0;
-  /**
-   * @brief	This method allows to set the valid information of the pool entry.
-   */
-  virtual bool getValid() = 0;
+
   /**
    * @brief	This is a debug method that prints all values and the valid
    * 			information to the screen. It prints all array entries in a row.
diff --git a/src/fsfw/datapool/PoolVariable.h b/src/fsfw/datapool/PoolVariable.h
new file mode 100644
index 00000000..a6b82174
--- /dev/null
+++ b/src/fsfw/datapool/PoolVariable.h
@@ -0,0 +1,348 @@
+#pragma once
+
+#include <fsfw/datapool/internal/SharedPoolAttorney.h>
+
+#include "FSFWConfig.h"
+#include "LocalPoolObjectBase.h"
+#include "fsfw/datapool/DataSetIF.h"
+#include "fsfw/datapool/PoolVariableIF.h"
+#include "fsfw/serialize/SerializeAdapter.h"
+
+namespace datapool {
+
+/**
+ * @brief 	Local Pool Variable class which is used to access the local pools.
+ * @details
+ * This class is not stored in the map. Instead, it is used to access
+ * the pool entries by using a pointer to the map storing the pool
+ * entries. It can also be used to organize these pool entries into data sets.
+ *
+ * @tparam T The template parameter sets the type of the variable. Currently,
+ * all plain data types are supported, but in principle  any type is possible.
+ * @ingroup data_pool
+ */
+template <typename T>
+class PoolVariable : public PoolObjectBase {
+ public:
+  //! Default ctor is forbidden.
+  PoolVariable() = delete;
+
+  /**
+   * This constructor is used by the data creators to have pool variable
+   * instances which can also be stored in datasets.
+   *
+   * It does not fetch the current value from the data pool, which
+   * has to be done by calling the read() operation.
+   * Datasets can be used to access multiple local pool entries in an
+   * efficient way. A pointer to a dataset can be passed to register
+   * the pool variable in that dataset directly.
+   * @param poolId ID of the local pool entry.
+   * @param hkOwner Pointer of the owner. This will generally be the calling
+   * class itself which passes "this".
+   * @param dataSet The data set in which the variable shall register itself.
+   * If nullptr, the variable is not registered.
+   * @param setReadWriteMode Specify the read-write mode of the pool variable.
+   */
+  PoolVariable(SharedPool& sharedPool, dp::id_t poolId, DataSetIF* dataSet = nullptr,
+               pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+
+  /**
+   * This constructor is used by data users like controllers to have
+   * access to the local pool variables of data creators by supplying
+   * the respective creator object ID.
+   *
+   * It does not fetch the current value from the data pool, which
+   * has to be done by calling the read() operation.
+   * Datasets can be used to access multiple local pool entries in an
+   * efficient way. A pointer to a dataset can be passed to register
+   * the pool variable in that dataset directly.
+   * @param poolId ID of the local pool entry.
+   * @param hkOwner object ID of the pool owner.
+   * @param dataSet The data set in which the variable shall register itself.
+   * If nullptr, the variable is not registered.
+   * @param setReadWriteMode Specify the read-write mode of the pool variable.
+   *
+   */
+  PoolVariable(object_id_t poolOwner, dp::id_t poolId, DataSetIF* dataSet = nullptr,
+               pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+  /**
+   * Variation which takes the global unique identifier of a pool variable.
+   * @param globalPoolId
+   * @param dataSet
+   * @param setReadWriteMode
+   */
+  PoolVariable(g_id_t globalPoolId, DataSetIF* dataSet = nullptr,
+               pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
+
+  virtual ~PoolVariable() {};
+
+  T get() const;
+
+  /**
+   * @brief	This is the local copy of the data pool entry.
+   * @details	The user can work on this attribute
+   * 			just like he would on a simple local variable.
+   */
+  T value = 0;
+
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          SerializeIF::Endianness streamEndianness) const override;
+  size_t getSerializedSize() const override;
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            SerializeIF::Endianness streamEndianness) override;
+
+  /**
+   * @brief	This is a call to read the array's values
+   * 			from the global data pool.
+   * @details
+   * When executed, this operation tries to fetch the pool entry with matching
+   * data pool id from the data pool and copies all array values and the valid
+   * information to its local attributes.
+   * In case of a failure (wrong type, size or pool id not found), the
+   * variable is set to zero and invalid.
+   * The read call is protected with a lock.
+   * It is recommended to use DataSets to read and commit multiple variables
+   * at once to avoid the overhead of unnecessary lock und unlock operations.
+   *
+   */
+  ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+                     uint32_t timeoutMs = 20) override;
+  /**
+   * @brief	The commit call copies the array values back to the data pool.
+   * @details
+   * It checks type and size, as well as if the variable is writable. If so,
+   * the value is copied and the local valid flag is written back as well.
+   * The read call is protected with a lock.
+   * It is recommended to use DataSets to read and commit multiple variables
+   * at once to avoid the overhead of unnecessary lock und unlock operations.
+   */
+  ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
+                       uint32_t timeoutMs = 20) override;
+
+  PoolVariable<T>& operator=(const T& newValue);
+  PoolVariable<T>& operator=(const PoolVariable<T>& newPoolVariable);
+
+  //! Explicit type conversion operator. Allows casting the class to
+  //! its template type to perform operations on value.
+  explicit operator T() const;
+
+  bool operator==(const PoolVariable<T>& other) const;
+  bool operator==(const T& other) const;
+
+  bool operator!=(const PoolVariable<T>& other) const;
+  bool operator!=(const T& other) const;
+
+  bool operator<(const PoolVariable<T>& other) const;
+  bool operator<(const T& other) const;
+
+  bool operator>(const PoolVariable<T>& other) const;
+  bool operator>(const T& other) const;
+
+ protected:
+  /**
+   * @brief	Like #read, but without a lock protection of the global pool.
+   * @details
+   * The operation does NOT provide any mutual exclusive protection by itself.
+   * This can be used if the lock is handled externally to avoid the overhead
+   * of consecutive lock und unlock operations.
+   * Declared protected to discourage free public usage.
+   */
+  ReturnValue_t readWithoutLock() override;
+  /**
+   * @brief	Like #commit, but without a lock protection of the global pool.
+   * @details
+   * The operation does NOT provide any mutual exclusive protection by itself.
+   * This can be used if the lock is handled externally to avoid the overhead
+   * of consecutive lock und unlock operations.
+   * Declared protected to discourage free public usage.
+   */
+  ReturnValue_t commitWithoutLock() override;
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+  // std::ostream is the type for object std::cout
+  template <typename U>
+  friend std::ostream& operator<<(std::ostream& out, const LocalPoolVariable<U>& var);
+#endif
+};
+
+template <typename T>
+PoolVariable<T>::PoolVariable(SharedPool& sharedPool, dp::id_t poolId, DataSetIF* dataSet,
+                              pool_rwm_t setReadWriteMode)
+    : PoolObjectBase(sharedPool, poolId, dataSet, setReadWriteMode) {}
+
+template <typename T>
+PoolVariable<T>::PoolVariable(object_id_t poolOwner, dp::id_t poolId, DataSetIF* dataSet,
+                              pool_rwm_t setReadWriteMode)
+    : PoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
+
+template <typename T>
+PoolVariable<T>::PoolVariable(g_id_t globalPoolId, DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
+    : PoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet, setReadWriteMode) {}
+
+template <typename T>
+ReturnValue_t PoolVariable<T>::read(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+  if (sharedPool == nullptr) {
+    return readWithoutLock();
+  }
+  MutexIF* mutex = sharedPool->getPoolMutex();
+  ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = readWithoutLock();
+  mutex->unlockMutex();
+  return result;
+}
+
+template <typename T>
+inline ReturnValue_t PoolVariable<T>::readWithoutLock() {
+  if (sharedPool == nullptr) {
+    return PoolVariableIF::INVALID_SHARED_POOL;
+  }
+  if (readWriteMode == pool_rwm_t::VAR_WRITE) {
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
+
+  PoolEntry<T>* poolEntry = nullptr;
+  if (ReturnValue_t result = sharedPool->fetchPoolEntry(localPoolId, &poolEntry);
+      result != returnvalue::OK) {
+    return result;
+  }
+
+  this->value = *(poolEntry->getDataPtr());
+  return returnvalue::OK;
+}
+
+template <typename T>
+inline ReturnValue_t PoolVariable<T>::commit(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+  if (sharedPool == nullptr) {
+    return commitWithoutLock();
+  }
+  MutexIF* mutex = sharedPool->getPoolMutex();
+  ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = commitWithoutLock();
+  mutex->unlockMutex();
+  return result;
+}
+
+template <typename T>
+ReturnValue_t PoolVariable<T>::commitWithoutLock() {
+  if (readWriteMode == pool_rwm_t::VAR_READ) {
+    return PoolVariableIF::INVALID_READ_WRITE_MODE;
+  }
+
+  PoolEntry<T>* poolEntry = nullptr;
+  ReturnValue_t result = sharedPool->fetchPoolEntry(localPoolId, &poolEntry);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  *(poolEntry->getDataPtr()) = this->value;
+  return returnvalue::OK;
+}
+
+template <typename T>
+ReturnValue_t PoolVariable<T>::serialize(uint8_t** buffer, size_t* size, const size_t max_size,
+                                         SerializeIF::Endianness streamEndianness) const {
+  return SerializeAdapter::serialize(&value, buffer, size, max_size, streamEndianness);
+}
+
+template <typename T>
+size_t PoolVariable<T>::getSerializedSize() const {
+  return SerializeAdapter::getSerializedSize(&value);
+}
+
+template <typename T>
+ReturnValue_t PoolVariable<T>::deSerialize(const uint8_t** buffer, size_t* size,
+                                           SerializeIF::Endianness streamEndianness) {
+  return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
+}
+template <typename T>
+T PoolVariable<T>::get() const {
+  return value;
+}
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+template <typename T>
+inline std::ostream& operator<<(std::ostream& out, const PoolVariable<T>& var) {
+  out << var.value;
+  return out;
+}
+#endif
+
+template <typename T>
+PoolVariable<T>::operator T() const {
+  return value;
+}
+
+template <typename T>
+PoolVariable<T>& PoolVariable<T>::operator=(const T& newValue) {
+  value = newValue;
+  return *this;
+}
+
+template <typename T>
+PoolVariable<T>& PoolVariable<T>::operator=(const PoolVariable<T>& newPoolVariable) {
+  value = newPoolVariable.value;
+  return *this;
+}
+
+template <typename T>
+bool PoolVariable<T>::operator==(const PoolVariable<T>& other) const {
+  return this->value == other.value;
+}
+
+template <typename T>
+bool PoolVariable<T>::operator==(const T& other) const {
+  return this->value == other;
+}
+
+template <typename T>
+bool PoolVariable<T>::operator!=(const PoolVariable& other) const {
+  return not(*this == other);
+}
+
+template <typename T>
+bool PoolVariable<T>::operator!=(const T& other) const {
+  return not(*this == other);
+}
+
+template <typename T>
+bool PoolVariable<T>::operator<(const PoolVariable<T>& other) const {
+  return this->value < other.value;
+}
+
+template <typename T>
+bool PoolVariable<T>::operator<(const T& other) const {
+  return this->value < other;
+}
+
+template <typename T>
+bool PoolVariable<T>::operator>(const PoolVariable<T>& other) const {
+  return not(*this < other);
+}
+
+template <typename T>
+bool PoolVariable<T>::operator>(const T& other) const {
+  return not(*this < other);
+}
+
+template <class T>
+using var_t = PoolVariable<T>;
+
+using bool_t = PoolVariable<uint8_t>;
+using u8_t = PoolVariable<uint8_t>;
+using u16_t = PoolVariable<uint16_t>;
+using u32_t = PoolVariable<uint32_t>;
+using u64_t = PoolVariable<uint64_t>;
+using i8_t = PoolVariable<int8_t>;
+using i16_t = PoolVariable<int16_t>;
+using i32_t = PoolVariable<int32_t>;
+using i64_t = PoolVariable<int64_t>;
+using f32_t = PoolVariable<float>;
+using f64_t = PoolVariable<double>;
+
+}  // namespace datapool
diff --git a/src/fsfw/datapool/PoolVariable.tpp b/src/fsfw/datapool/PoolVariable.tpp
new file mode 100644
index 00000000..6f70f09b
--- /dev/null
+++ b/src/fsfw/datapool/PoolVariable.tpp
@@ -0,0 +1 @@
+#pragma once
diff --git a/src/fsfw/datapool/PoolVariableIF.h b/src/fsfw/datapool/PoolVariableIF.h
index 69074310..a5a7ae14 100644
--- a/src/fsfw/datapool/PoolVariableIF.h
+++ b/src/fsfw/datapool/PoolVariableIF.h
@@ -23,6 +23,7 @@ class PoolVariableIF : public SerializeIF, public ReadCommitIF {
   static constexpr uint8_t INTERFACE_ID = CLASS_ID::POOL_VARIABLE_IF;
   static constexpr ReturnValue_t INVALID_READ_WRITE_MODE = MAKE_RETURN_CODE(0xA0);
   static constexpr ReturnValue_t INVALID_POOL_ENTRY = MAKE_RETURN_CODE(0xA1);
+  static constexpr ReturnValue_t INVALID_SHARED_POOL = MAKE_RETURN_CODE(0xA2);
 
   static constexpr bool VALID = 1;
   static constexpr bool INVALID = 0;
@@ -46,15 +47,6 @@ class PoolVariableIF : public SerializeIF, public ReadCommitIF {
    * @brief	This operation shall return the data pool id of the variable.
    */
   virtual uint32_t getDataPoolId() const = 0;
-  /**
-   * @brief	With this call, the valid information of the
-   * 			variable is returned.
-   */
-  virtual bool isValid() const = 0;
-  /**
-   * @brief	With this call, the valid information of the variable is set.
-   */
-  virtual void setValid(bool validity) = 0;
 };
 
 using pool_rwm_t = PoolVariableIF::ReadWriteMode_t;
diff --git a/src/fsfw/datapool/SharedPool.cpp b/src/fsfw/datapool/SharedPool.cpp
new file mode 100644
index 00000000..59fea2bc
--- /dev/null
+++ b/src/fsfw/datapool/SharedPool.cpp
@@ -0,0 +1,36 @@
+#include "SharedPool.h"
+
+#include "FSFWConfig.h"
+#include "fsfw/ipc/MutexFactory.h"
+#include "fsfw/serviceinterface.h"
+
+using namespace dp;
+SharedPool::SharedPool(object_id_t ownerId) : ownerId(ownerId) {
+  mutex = MutexFactory::instance()->createMutex();
+  if (mutex == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "localpool::Manager: Mutex creation failed" << std::endl;
+#else
+    sif::printError("localpool::Manager: Mutex creation failed");
+#endif
+  }
+}
+
+SharedPool::~SharedPool() { MutexFactory::instance()->deleteMutex(mutex); }
+
+object_id_t SharedPool::getOwnerId() const { return ownerId; }
+
+void SharedPool::addPoolEntry(id_t poolId, PoolEntryIF* entry) {
+  localPoolMap.emplace(poolId, entry);
+}
+
+MutexIF* SharedPool::getPoolMutex() { return mutex; }
+
+ReturnValue_t SharedPool::printPoolEntry(id_t localPoolId) {
+  auto poolIter = localPoolMap.find(localPoolId);
+  if (poolIter == localPoolMap.end()) {
+    return POOL_ENTRY_NOT_FOUND;
+  }
+  poolIter->second->print();
+  return returnvalue::OK;
+}
diff --git a/src/fsfw/datapool/SharedPool.h b/src/fsfw/datapool/SharedPool.h
new file mode 100644
index 00000000..277dc76a
--- /dev/null
+++ b/src/fsfw/datapool/SharedPool.h
@@ -0,0 +1,62 @@
+#pragma once
+
+#include "fsfw/datapool/PoolEntry.h"
+#include "fsfw/datapool/definitions.h"
+#include "fsfw/ipc/MutexIF.h"
+
+namespace datapool {
+
+class SharedPool {
+ public:
+  explicit SharedPool(object_id_t ownerId);
+  ~SharedPool();
+
+  [[nodiscard]] object_id_t getOwnerId() const;
+
+  /**
+   * Read a variable by supplying its local pool ID and assign the pool
+   * entry to the supplied PoolEntry pointer. The type of the pool entry
+   * is deduced automatically. This call is not thread-safe!
+   * For now, only classes designated by the LocalDpManagerAttorney may use this function.
+   * @tparam T Type of the pool entry
+   * @param localPoolId Pool ID of the variable to read
+   * @param poolVar [out] Corresponding pool entry will be assigned to the
+   * 						supplied pointer.
+   * @return
+   */
+  template <class T>
+  ReturnValue_t fetchPoolEntry(id_t localPoolId, PoolEntry<T>** poolEntry);
+  ReturnValue_t printPoolEntry(id_t localPoolId);
+  void addPoolEntry(id_t poolId, PoolEntryIF* entry);
+  MutexIF* getPoolMutex();
+
+ private:
+  object_id_t ownerId;
+
+  // Core data structure for the actual pool data
+  DataPool localPoolMap{};
+  // Every housekeeping data manager has a mutex to protect access
+  // to it's data pool.
+  MutexIF* mutex = nullptr;
+};
+
+template <class T>
+inline ReturnValue_t datapool::SharedPool::fetchPoolEntry(id_t localPoolId,
+                                                          PoolEntry<T>** poolEntry) {
+  if (poolEntry == nullptr) {
+    return returnvalue::FAILED;
+  }
+
+  auto poolIter = localPoolMap.find(localPoolId);
+  if (poolIter == localPoolMap.end()) {
+    return POOL_ENTRY_NOT_FOUND;
+  }
+
+  *poolEntry = dynamic_cast<PoolEntry<T>*>(poolIter->second);
+  if (*poolEntry == nullptr) {
+    return POOL_ENTRY_TYPE_CONFLICT;
+  }
+  return returnvalue::OK;
+}
+
+}  // namespace datapool
diff --git a/src/fsfw/datapool/SharedSet.cpp b/src/fsfw/datapool/SharedSet.cpp
new file mode 100644
index 00000000..3150e2f3
--- /dev/null
+++ b/src/fsfw/datapool/SharedSet.cpp
@@ -0,0 +1,16 @@
+#include "SharedSet.h"
+
+using namespace dp;
+
+SharedSet::SharedSet(dp::SharedPool& sharedPool, uint32_t setId, const size_t maxNumberOfVariables)
+    : SharedSetBase(sharedPool, setId, nullptr, maxNumberOfVariables),
+      poolVarList(maxNumberOfVariables) {
+  this->setContainer(poolVarList.data());
+}
+
+SharedSet::SharedSet(dp::structure_id_t sid, const size_t maxNumberOfVariables)
+    : SharedSetBase(sid, nullptr, maxNumberOfVariables), poolVarList(maxNumberOfVariables) {
+  this->setContainer(poolVarList.data());
+}
+
+SharedSet::~SharedSet() = default;
diff --git a/src/fsfw/datapoollocal/LocalDataSet.h b/src/fsfw/datapool/SharedSet.h
similarity index 59%
rename from src/fsfw/datapoollocal/LocalDataSet.h
rename to src/fsfw/datapool/SharedSet.h
index f369cb2c..f7d516c9 100644
--- a/src/fsfw/datapoollocal/LocalDataSet.h
+++ b/src/fsfw/datapool/SharedSet.h
@@ -1,10 +1,11 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCALDATASET_H_
-#define FSFW_DATAPOOLLOCAL_LOCALDATASET_H_
+#pragma once
 
 #include <vector>
 
-#include "LocalPoolDataSetBase.h"
+#include "SharedPool.h"
+#include "SharedSetBase.h"
 
+namespace datapool {
 /**
  * @brief   This dataset type can be used to group related pool variables if the number of
  *          variables should not be fixed.
@@ -18,20 +19,20 @@
  * @tparam capacity Capacity of the static dataset, which is usually known
  * beforehand.
  */
-class LocalDataSet : public LocalPoolDataSetBase {
+class SharedSet : public SharedSetBase {
  public:
-  LocalDataSet(HasLocalDataPoolIF* hkOwner, uint32_t setId, const size_t maxSize);
+  SharedSet(SharedPool& sharedPool, uint32_t setId, size_t maxSize);
 
-  LocalDataSet(sid_t sid, const size_t maxSize);
+  SharedSet(sid_t sid, size_t maxSize);
 
-  virtual ~LocalDataSet();
+  ~SharedSet() override;
 
   //! Copying forbidden for now.
-  LocalDataSet(const LocalDataSet&) = delete;
-  LocalDataSet& operator=(const LocalDataSet&) = delete;
+  SharedSet(const SharedSet&) = delete;
+  SharedSet& operator=(const SharedSet&) = delete;
 
  private:
   std::vector<PoolVariableIF*> poolVarList;
 };
 
-#endif /* FSFW_DATAPOOLLOCAL_LOCALDATASET_H_ */
+}  // namespace datapool
diff --git a/src/fsfw/datapool/SharedSetBase.cpp b/src/fsfw/datapool/SharedSetBase.cpp
new file mode 100644
index 00000000..36482ec3
--- /dev/null
+++ b/src/fsfw/datapool/SharedSetBase.cpp
@@ -0,0 +1,153 @@
+#include "SharedSetBase.h"
+
+#include <fsfw/housekeeping/GeneratesPeriodicHkIF.h>
+
+#include <cmath>
+
+#include "fsfw/datapool.h"
+#include "fsfw/globalfunctions/bitutility.h"
+#include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/serialize/SerializeAdapter.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+
+using namespace datapool;
+
+SharedSetBase::SharedSetBase(SharedPool &sharedPool, uint32_t setId,
+                             PoolVariableIF **registeredVariablesArray,
+                             const size_t maxNumberOfVariables)
+    : base(registeredVariablesArray, maxNumberOfVariables), sharedPool(&sharedPool) {
+  mutexIfSingleDataCreator = sharedPool.getPoolMutex();
+
+  this->sid.objectId = sharedPool.getOwnerId();
+  this->sid.ownerSetId = setId;
+}
+
+SharedSetBase::SharedSetBase(structure_id_t sid, PoolVariableIF **registeredVariablesArray,
+                             const size_t maxNumberOfVariables)
+    : base(registeredVariablesArray, maxNumberOfVariables) {
+  auto *hkOwner = ObjectManager::instance()->get<hk::GeneratesPeriodicHkIF>(sid.objectId);
+  if (hkOwner != nullptr) {
+    sharedPool = hkOwner->getOptionalSharedPool();
+    if (sharedPool != nullptr) {
+      mutexIfSingleDataCreator = sharedPool->getPoolMutex();
+    }
+  }
+
+  this->sid = sid;
+}
+
+SharedSetBase::SharedSetBase(PoolVariableIF **registeredVariablesArray,
+                             const size_t maxNumberOfVariables, bool protectEveryReadCommitCall)
+    : base(registeredVariablesArray, maxNumberOfVariables) {
+  base.setReadCommitProtectionBehaviour(protectEveryReadCommitCall);
+}
+
+SharedSetBase::~SharedSetBase() {
+  // In case set was read but not comitted, we commit all variables with an invalid state
+  if (base.state == PoolDataSetBase::States::STATE_SET_WAS_READ) {
+    for (uint16_t count = 0; count < base.getFillCount(); count++) {
+      if (base.registeredVariables[count] != nullptr) {
+        base.registeredVariables[count]->commit(MutexIF::TimeoutType::WAITING, 20);
+      }
+    }
+  }
+}
+
+ReturnValue_t SharedSetBase::lockDataPool(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+  if (mutexIfSingleDataCreator != nullptr) {
+    return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t SharedSetBase::unlockDataPool() {
+  if (mutexIfSingleDataCreator != nullptr) {
+    return mutexIfSingleDataCreator->unlockMutex();
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t SharedSetBase::serializeLocalPoolIds(uint8_t **buffer, size_t *size, size_t maxSize,
+                                                   SerializeIF::Endianness streamEndianness) const {
+  /* Serialize fill count as uint8_t */
+  auto fillCount = this->getFillCount();
+  for (uint16_t count = 0; count < fillCount; count++) {
+    id_t currentPoolId = base.registeredVariables[count]->getDataPoolId();
+    auto result =
+        SerializeAdapter::serialize(&currentPoolId, buffer, size, maxSize, streamEndianness);
+    if (result != returnvalue::OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: " << "Serialization error!"
+                   << std::endl;
+#else
+      sif::printWarning(
+          "LocalPoolDataSetBase::serializeLocalPoolIds: "
+          "Serialization error!\n\r");
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+      return result;
+    }
+  }
+  return returnvalue::OK;
+}
+
+size_t SharedSetBase::getLocalPoolIdsSerializedSize() const {
+  return base.getFillCount() * sizeof(id_t);
+}
+
+size_t SharedSetBase::getSerializedSize() const { return base.getSerializedSize(); }
+
+ReturnValue_t SharedSetBase::deSerialize(const uint8_t **buffer, size_t *size,
+                                         SerializeIF::Endianness streamEndianness) {
+  return base.deSerialize(buffer, size, streamEndianness);
+}
+
+ReturnValue_t SharedSetBase::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                       SerializeIF::Endianness streamEndianness) const {
+  return base.serialize(buffer, size, maxSize, streamEndianness);
+}
+
+[[nodiscard]] ReturnValue_t SharedSetBase::serialize(
+    uint8_t *buffer, size_t &serLen, size_t maxSize,
+    SerializeIF::Endianness streamEndianness) const {
+  return SerializeIF::serialize(buffer, serLen, maxSize, streamEndianness);
+}
+
+void SharedSetBase::setReportingEnabled(bool reportingEnabled) {
+  this->reportingEnabled = reportingEnabled;
+}
+
+bool SharedSetBase::getReportingEnabled() const { return reportingEnabled; }
+
+structure_id_t SharedSetBase::getStructureId() const { return sid; }
+
+object_id_t SharedSetBase::getCreatorObjectId() {
+  if (sharedPool != nullptr) {
+    return sharedPool->getOwnerId();
+  }
+  return objects::NO_OBJECT;
+}
+
+void SharedSetBase::setAllVariablesReadOnly() {
+  for (size_t idx = 0; idx < this->getFillCount(); idx++) {
+    base.registeredVariables[idx]->setReadWriteMode(pool_rwm_t::VAR_READ);
+  }
+}
+
+void SharedSetBase::printSet() { return; }
+
+ReturnValue_t SharedSetBase::read(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+  return base.read(timeoutType, timeoutMs);
+}
+ReturnValue_t SharedSetBase::commit(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
+  return base.commit(timeoutType, timeoutMs);
+}
+uint16_t SharedSetBase::getFillCount() const { return base.getFillCount(); }
+
+ReturnValue_t SharedSetBase::registerVariable(PoolVariableIF *variable) {
+  return base.registerVariable(variable);
+}
+
+void SharedSetBase::setContainer(PoolVariableIF **variablesContainer) {
+  return base.setContainer(variablesContainer);
+}
+PoolVariableIF **SharedSetBase::getContainer() const { return base.getContainer(); }
diff --git a/src/fsfw/datapoollocal/LocalPoolDataSetBase.h b/src/fsfw/datapool/SharedSetBase.h
similarity index 59%
rename from src/fsfw/datapoollocal/LocalPoolDataSetBase.h
rename to src/fsfw/datapool/SharedSetBase.h
index 600a890a..34ebd0f1 100644
--- a/src/fsfw/datapoollocal/LocalPoolDataSetBase.h
+++ b/src/fsfw/datapool/SharedSetBase.h
@@ -1,17 +1,16 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
-#define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_
+#pragma once
 
-#include <vector>
-
-#include "MarkChangedIF.h"
+#include "SharedPool.h"
+#include "definitions.h"
 #include "fsfw/datapool/DataSetIF.h"
 #include "fsfw/datapool/PoolDataSetBase.h"
-#include "localPoolDefinitions.h"
 
-class LocalDataPoolManager;
-class HasLocalDataPoolIF;
+class PeriodicHkGenerationHelper;
+class PeriodicHkGenerationIF;
 class PeriodicHousekeepingHelper;
 
+namespace datapool {
+
 /**
  * @brief	The LocalDataSet class manages a set of locally checked out
  *          variables for local data pools
@@ -40,9 +39,8 @@ class PeriodicHousekeepingHelper;
  *
  * @ingroup data_pool
  */
-class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
-  friend class LocalPoolDataSetAttorney;
-  friend class PeriodicHousekeepingHelper;
+class SharedSetBase : public SerializeIF, public PoolDataSetIF {
+  // friend class PeriodicHousekeepingHelper;
 
  public:
   /**
@@ -51,9 +49,8 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    * This constructor also initializes the components required for
    * periodic handling.
    */
-  LocalPoolDataSetBase(HasLocalDataPoolIF* hkOwner, uint32_t setId,
-                       PoolVariableIF** registeredVariablesArray, const size_t maxNumberOfVariables,
-                       bool periodicHandling = true);
+  SharedSetBase(SharedPool& sharedPool, uint32_t setId, PoolVariableIF** registeredVariablesArray,
+                size_t maxNumberOfVariables);
 
   /**
    * @brief	Constructor for users of the local pool data, which need
@@ -66,8 +63,7 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    * @param registeredVariablesArray
    * @param maxNumberOfVariables
    */
-  LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
-                       const size_t maxNumberOfVariables);
+  SharedSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray, size_t maxNumberOfVariables);
 
   /**
    * @brief	Simple constructor, if the dataset is not the owner by
@@ -87,8 +83,8 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    * multiple creators, this flag can be set to protect all read and
    * commit calls separately.
    */
-  LocalPoolDataSetBase(PoolVariableIF** registeredVariablesArray, const size_t maxNumberOfVariables,
-                       bool protectEveryReadCommitCall = true);
+  SharedSetBase(PoolVariableIF** registeredVariablesArray, size_t maxNumberOfVariables,
+                bool protectEveryReadCommitCall = true);
 
   /**
    * @brief	The destructor automatically manages writing the valid
@@ -98,13 +94,13 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    * the destructor parses all variables that are still registered to the set.
    * For each, the valid flag in the data pool is set to "invalid".
    */
-  ~LocalPoolDataSetBase();
+  ~SharedSetBase() override;
 
   /* The copy constructor and assingment constructor are forbidden for now.
   The use-cases are limited and the first step would be to implement them properly for the
   base class */
-  LocalPoolDataSetBase(const LocalPoolDataSetBase& otherSet) = delete;
-  const LocalPoolDataSetBase& operator=(const LocalPoolDataSetBase& otherSet) = delete;
+  SharedSetBase(const SharedSetBase& otherSet) = delete;
+  const SharedSetBase& operator=(const SharedSetBase& otherSet) = delete;
 
   /**
    * Helper functions used to set all currently contained variables to read-only.
@@ -112,56 +108,27 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    * by data consumers to prevent accidentally changing pool data.
    */
   void setAllVariablesReadOnly();
-  void setValidityBufferGeneration(bool withValidityBuffer);
 
-  sid_t getSid() const;
+  [[nodiscard]] ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                                        Endianness streamEndianness) const override;
+
+  [[nodiscard]] ReturnValue_t serialize(uint8_t* buffer, size_t& serLen, size_t maxSize,
+                                        SerializeIF::Endianness streamEndianness) const override;
 
-  /** SerializeIF overrides */
-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          SerializeIF::Endianness streamEndianness) const override;
   ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                            SerializeIF::Endianness streamEndianness) override;
-  size_t getSerializedSize() const override;
+                            Endianness streamEndianness) override;
+
+  [[nodiscard]] dp::sid_t getStructureId() const;
+
+  [[nodiscard]] size_t getSerializedSize() const override;
 
-  /**
-   * Special version of the serilization function which appends a
-   * validity buffer at the end. Each bit of this validity buffer
-   * denotes whether the container data set entries are valid from left
-   * to right, MSB first. (length = ceil(N/8), N = number of pool variables)
-   * @param buffer
-   * @param size
-   * @param maxSize
-   * @param bigEndian
-   * @param withValidityBuffer
-   * @return
-   */
-  ReturnValue_t serializeWithValidityBuffer(uint8_t** buffer, size_t* size, size_t maxSize,
-                                            SerializeIF::Endianness streamEndianness) const;
-  ReturnValue_t deSerializeWithValidityBuffer(const uint8_t** buffer, size_t* size,
-                                              SerializeIF::Endianness streamEndianness);
   ReturnValue_t serializeLocalPoolIds(uint8_t** buffer, size_t* size, size_t maxSize,
-                                      SerializeIF::Endianness streamEndianness,
-                                      bool serializeFillCount = true) const;
-  uint8_t getLocalPoolIdsSerializedSize(bool serializeFillCount = true) const;
-
-  /**
-   * Set the dataset valid or invalid. These calls are mutex protected.
-   * @param setEntriesRecursively
-   * If this is true, all contained datasets will also be set recursively.
-   */
-  void setValidity(bool valid, bool setEntriesRecursively);
-  bool isValid() const override;
-
-  /**
-   * These calls are mutex protected.
-   * @param changed
-   */
-  void setChanged(bool changed) override;
-  bool hasChanged() const override;
+                                      SerializeIF::Endianness streamEndianness) const;
+  [[nodiscard]] size_t getLocalPoolIdsSerializedSize() const;
 
   object_id_t getCreatorObjectId();
 
-  bool getReportingEnabled() const;
+  [[nodiscard]] bool getReportingEnabled() const;
   void setReportingEnabled(bool enabled);
 
   /**
@@ -170,14 +137,27 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    * returns 0.0
    * @return
    */
-  float getCollectionInterval() const;
+  [[nodiscard]] float getCollectionInterval() const;
 
   /**
    * @brief   Can be overwritten by a specific implementation of a dataset to print the set.
    */
   virtual void printSet();
 
+  ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::BLOCKING,
+                     dur_millis_t timeoutMs = 0) override;
+  ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::BLOCKING,
+                       dur_millis_t timeoutMs = 0) override;
+  uint16_t getFillCount() const override;
+
+  ReturnValue_t registerVariable(PoolVariableIF* variable) override;
+
+  void setContainer(PoolVariableIF** variablesContainer);
+  PoolVariableIF** getContainer() const;
+
  protected:
+  PoolDataSetBase base;
+
   sid_t sid;
   //! This mutex is used if the data is created by one object only.
   MutexIF* mutexIfSingleDataCreator = nullptr;
@@ -195,21 +175,6 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    */
   bool valid = false;
 
-  /**
-   * Can be used to mark the dataset as changed, which is used
-   * by the LocalDataPoolManager to send out update messages.
-   */
-  bool changed = false;
-
-  /**
-   * Specify whether the validity buffer is serialized too when serializing
-   * or deserializing the packet. Each bit of the validity buffer will
-   * contain the validity state of the pool variables from left to right.
-   * The size of validity buffer thus will be ceil(N / 8) with N = number of
-   * pool variables.
-   */
-  bool withValidityBuffer = true;
-
   /**
    * @brief	This is a small helper function to facilitate locking
    * 			the global data pool.
@@ -226,8 +191,7 @@ class LocalPoolDataSetBase : public PoolDataSetBase, public MarkChangedIF {
    */
   ReturnValue_t unlockDataPool() override;
 
-  PeriodicHousekeepingHelper* periodicHelper = nullptr;
-  LocalDataPoolManager* poolManager = nullptr;
+  dp::SharedPool* sharedPool = nullptr;
 };
 
-#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETBASE_H_ */
+}  // namespace datapool
\ No newline at end of file
diff --git a/src/fsfw/datapoollocal/StaticLocalDataSet.h b/src/fsfw/datapool/StaticSharedSet.h
similarity index 56%
rename from src/fsfw/datapoollocal/StaticLocalDataSet.h
rename to src/fsfw/datapool/StaticSharedSet.h
index 59047d67..7c96010f 100644
--- a/src/fsfw/datapoollocal/StaticLocalDataSet.h
+++ b/src/fsfw/datapool/StaticSharedSet.h
@@ -1,13 +1,10 @@
-#ifndef FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_
-#define FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_
+#pragma once
 
 #include <array>
 
-#include "../objectmanager/SystemObjectIF.h"
-#include "LocalPoolDataSetBase.h"
-#include "LocalPoolVariable.h"
-#include "LocalPoolVector.h"
+#include "SharedSetBase.h"
 
+namespace datapool {
 /**
  * @brief   This dataset type can be used to group related pool variables if the number of
  *          variables is fixed.
@@ -18,30 +15,29 @@
  *
  * It is recommended to read the documentation of the LocalPoolDataSetBase
  * class for more information on how this class works and how to use it.
- * @tparam capacity Capacity of the static dataset, which is usually known
+ * @tparam NUM_VARIABLES Capacity of the static dataset, which is usually known
  * beforehand.
  */
-template <uint8_t NUM_VARIABLES>
-class StaticLocalDataSet : public LocalPoolDataSetBase {
+template <size_t NUM_VARIABLES>
+class StaticSharedSet : public datapool::SharedSetBase {
  public:
   /**
    * Constructor used by data owner and creator like device handlers.
    * This constructor also initialized the components required for
    * periodic handling.
-   * @param hkOwner
+   * @param sharedPool Shared pool this dataset will read from or write to.
    * @param setId
    */
-  StaticLocalDataSet(HasLocalDataPoolIF* hkOwner, uint32_t setId)
-      : LocalPoolDataSetBase(hkOwner, setId, nullptr, NUM_VARIABLES) {
+  StaticSharedSet(SharedPool& sharedPool, const uint32_t setId)
+      : SharedSetBase(sharedPool, setId, nullptr, NUM_VARIABLES) {
     this->setContainer(poolVarList.data());
   }
 
   /**
    * Constructor used by data users like controllers.
-   * @param hkOwner
-   * @param setId
+   * @param sid
    */
-  StaticLocalDataSet(sid_t sid) : LocalPoolDataSetBase(sid, nullptr, NUM_VARIABLES) {
+  explicit StaticSharedSet(const structure_id_t sid) : SharedSetBase(sid, nullptr, NUM_VARIABLES) {
     this->setContainer(poolVarList.data());
   }
 
@@ -49,4 +45,4 @@ class StaticLocalDataSet : public LocalPoolDataSetBase {
   std::array<PoolVariableIF*, NUM_VARIABLES> poolVarList = {};
 };
 
-#endif /* FSFW_DATAPOOLLOCAL_STATICLOCALDATASET_H_ */
+}  // namespace datapool
\ No newline at end of file
diff --git a/src/fsfw/datapoollocal/localPoolDefinitions.h b/src/fsfw/datapool/definitions.h
similarity index 57%
rename from src/fsfw/datapoollocal/localPoolDefinitions.h
rename to src/fsfw/datapool/definitions.h
index 07bfbfa8..eacab98a 100644
--- a/src/fsfw/datapoollocal/localPoolDefinitions.h
+++ b/src/fsfw/datapool/definitions.h
@@ -1,5 +1,4 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_
-#define FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_
+#pragma once
 
 #include <cstdint>
 #include <map>
@@ -8,37 +7,38 @@
 #include "../objectmanager/SystemObjectIF.h"
 #include "../objectmanager/frameworkObjects.h"
 
+namespace datapool {
+
 /**
  * @brief   Type definition for local pool entries.
  */
-using lp_id_t = uint32_t;
+using id_t = uint32_t;
 
-namespace localpool {
 static constexpr uint32_t INVALID_LPID = -1;
 
-static constexpr uint8_t INTERFACE_ID = CLASS_ID::LOCAL_POOL_OWNER_IF;
+static constexpr uint8_t INTERFACE_ID = CLASS_ID::DATAPOOL_IF;
 
 static constexpr ReturnValue_t POOL_ENTRY_NOT_FOUND = MAKE_RETURN_CODE(0x00);
 static constexpr ReturnValue_t POOL_ENTRY_TYPE_CONFLICT = MAKE_RETURN_CODE(0x01);
 
 /** This is the core data structure of the local data pools. Users should insert all desired
 pool variables, using the std::map interface. */
-using DataPool = std::map<lp_id_t, PoolEntryIF*>;
-using DataPoolMapIter = DataPool::iterator;
-
-}  // namespace localpool
+using DataPool = std::map<id_t, PoolEntryIF*>;
 
 /**
  * Used as a unique identifier for data sets. Consists of 4 byte object ID and 4 byte set ID.
  */
-union sid_t {
+union structure_id_t {
+  static constexpr size_t SIZE = sizeof(object_id_t) + sizeof(uint32_t);
+
   static constexpr uint64_t INVALID_SID = -1;
   static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
   static constexpr uint32_t INVALID_SET_ID = -1;
 
-  sid_t() : raw(INVALID_SID) {}
+  structure_id_t() : raw(INVALID_SID) {}
 
-  sid_t(object_id_t objectId, uint32_t setId) : objectId(objectId), ownerSetId(setId) {}
+  constexpr structure_id_t(object_id_t objectId, uint32_t setId)
+      : objectId(objectId), ownerSetId(setId) {}
 
   struct {
     object_id_t objectId;
@@ -54,39 +54,41 @@ union sid_t {
    */
   uint64_t raw;
 
-  bool notSet() const { return raw == INVALID_SID; }
+  [[nodiscard]] bool notSet() const { return raw == INVALID_SID; }
 
-  bool operator==(const sid_t& other) const { return raw == other.raw; }
+  bool operator==(const structure_id_t& other) const { return raw == other.raw; }
 
-  bool operator!=(const sid_t& other) const { return not(raw == other.raw); }
+  bool operator!=(const structure_id_t& other) const { return not(raw == other.raw); }
 };
 
+using sid_t = structure_id_t;
+
 /**
  * Used as a global unique identifier for local pool variables. Consists of 4 byte object ID
  * and 4 byte local pool ID.
  */
-union gp_id_t {
+union g_id_t {
   static constexpr uint64_t INVALID_GPID = -1;
   static constexpr uint32_t INVALID_OBJECT_ID = objects::NO_OBJECT;
-  static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
 
-  gp_id_t() : raw(INVALID_GPID) {}
+  g_id_t() : raw(INVALID_GPID) {}
 
-  gp_id_t(object_id_t objectId, lp_id_t localPoolId)
-      : objectId(objectId), localPoolId(localPoolId) {}
+  g_id_t(object_id_t objectId, id_t localPoolId) : objectId(objectId), localPoolId(localPoolId) {}
 
   struct {
     object_id_t objectId;
-    lp_id_t localPoolId;
+    id_t localPoolId;
   };
 
   uint64_t raw;
 
   bool notSet() const { return raw == INVALID_GPID; }
 
-  bool operator==(const gp_id_t& other) const { return raw == other.raw; }
+  bool operator==(const g_id_t& other) const { return raw == other.raw; }
 
-  bool operator!=(const gp_id_t& other) const { return not(raw == other.raw); }
+  bool operator!=(const g_id_t& other) const { return not(raw == other.raw); }
 };
 
-#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDEFINITIONS_H_ */
+}  // namespace datapool
+
+namespace dp = datapool;
\ No newline at end of file
diff --git a/src/fsfw/datapool/internal/CMakeLists.txt b/src/fsfw/datapool/internal/CMakeLists.txt
new file mode 100644
index 00000000..a0d48465
--- /dev/null
+++ b/src/fsfw/datapool/internal/CMakeLists.txt
@@ -0,0 +1 @@
+target_sources(${LIB_FSFW_NAME} PRIVATE)
diff --git a/src/fsfw/datapool/internal/LocalPoolDataSetAttorney.h b/src/fsfw/datapool/internal/LocalPoolDataSetAttorney.h
new file mode 100644
index 00000000..d2932f4c
--- /dev/null
+++ b/src/fsfw/datapool/internal/LocalPoolDataSetAttorney.h
@@ -0,0 +1,11 @@
+#pragma once
+
+#include "fsfw/datapool/SharedSetBase.h"
+
+class LocalPoolDataSetAttorney {
+  static void setReportingEnabled(SharedDatasetBase& set, bool enabled) {
+    set.setReportingEnabled(enabled);
+  }
+
+  static bool getReportingEnabled(SharedDatasetBase& set) { return set.getReportingEnabled(); }
+};
\ No newline at end of file
diff --git a/src/fsfw/datapoollocal/internal/LocalDpManagerAttorney.h b/src/fsfw/datapool/internal/SharedPoolAttorney.h
similarity index 67%
rename from src/fsfw/datapoollocal/internal/LocalDpManagerAttorney.h
rename to src/fsfw/datapool/internal/SharedPoolAttorney.h
index 95051a3e..1d9198ed 100644
--- a/src/fsfw/datapoollocal/internal/LocalDpManagerAttorney.h
+++ b/src/fsfw/datapool/internal/SharedPoolAttorney.h
@@ -1,8 +1,8 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
-#define FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_
+#pragma once
 
-#include "../LocalDataPoolManager.h"
+#include "fsfw/datapool/SharedPool.h"
 
+namespace datapool {
 /**
  * @brief	This is a helper class implements the Attorney-Client idiom for access to
  * 			LocalDataPoolManager internals
@@ -13,15 +13,15 @@
  * an explicit subset of the pool manager private/protected functions.
  * See: https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Friendship_and_the_Attorney-Client
  */
-class LocalDpManagerAttorney {
+class SharedPoolAttorney {
  private:
   template <typename T>
-  static ReturnValue_t fetchPoolEntry(LocalDataPoolManager& manager, lp_id_t localPoolId,
+  static ReturnValue_t fetchPoolEntry(SharedPool& manager, dp::id_t localPoolId,
                                       PoolEntry<T>** poolEntry) {
     return manager.fetchPoolEntry(localPoolId, poolEntry);
   }
 
-  static MutexIF* getMutexHandle(LocalDataPoolManager& manager) { return manager.getMutexHandle(); }
+  static MutexIF* getMutexHandle(SharedPool& manager) { return manager.getPoolMutex(); }
 
   template <typename T>
   friend class LocalPoolVariable;
@@ -29,4 +29,4 @@ class LocalDpManagerAttorney {
   friend class LocalPoolVector;
 };
 
-#endif /* FSFW_DATAPOOLLOCAL_LOCALDPMANAGERATTORNEY_H_ */
+}  // namespace datapool
\ No newline at end of file
diff --git a/src/fsfw/datapoollocal.h b/src/fsfw/datapoollocal.h
deleted file mode 100644
index 26021e08..00000000
--- a/src/fsfw/datapoollocal.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_
-#define FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_
-
-/* Collected related headers */
-#include "fsfw/datapoollocal/LocalDataSet.h"
-#include "fsfw/datapoollocal/LocalPoolVariable.h"
-#include "fsfw/datapoollocal/LocalPoolVector.h"
-#include "fsfw/datapoollocal/SharedLocalDataSet.h"
-#include "fsfw/datapoollocal/StaticLocalDataSet.h"
-
-#endif /* FSFW_DATAPOOLLOCAL_DATAPOOLLOCAL_H_ */
diff --git a/src/fsfw/datapoollocal/AccessLocalPoolF.h b/src/fsfw/datapoollocal/AccessLocalPoolF.h
deleted file mode 100644
index eaeda783..00000000
--- a/src/fsfw/datapoollocal/AccessLocalPoolF.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
-#define FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_
-
-class LocalDataPoolManager;
-class MutexIF;
-
-/**
- * @brief 	Accessor class which can be used by classes which like to use the pool manager.
- */
-class AccessPoolManagerIF {
- public:
-  virtual ~AccessPoolManagerIF() {};
-
-  virtual MutexIF* getLocalPoolMutex() = 0;
-
-  /**
-   * Can be used to get a handle to the local data pool manager.
-   * This function is protected because it should only be used by the
-   * class imlementing the interface.
-   */
-  virtual LocalDataPoolManager* getPoolManagerHandle() = 0;
-
- protected:
-};
-
-#endif /* FSFW_DATAPOOLLOCAL_ACCESSLOCALPOOLF_H_ */
diff --git a/src/fsfw/datapoollocal/CMakeLists.txt b/src/fsfw/datapoollocal/CMakeLists.txt
deleted file mode 100644
index 749ef688..00000000
--- a/src/fsfw/datapoollocal/CMakeLists.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-target_sources(
-  ${LIB_FSFW_NAME}
-  PRIVATE LocalDataPoolManager.cpp LocalDataSet.cpp LocalPoolDataSetBase.cpp
-          LocalPoolObjectBase.cpp SharedLocalDataSet.cpp)
-
-add_subdirectory(internal)
diff --git a/src/fsfw/datapoollocal/HasLocalDataPoolIF.h b/src/fsfw/datapoollocal/HasLocalDataPoolIF.h
deleted file mode 100644
index 9313571f..00000000
--- a/src/fsfw/datapoollocal/HasLocalDataPoolIF.h
+++ /dev/null
@@ -1,181 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
-#define FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_
-
-#include <map>
-
-#include "LocalDataPoolManager.h"
-#include "fsfw/datapool/PoolEntryIF.h"
-#include "fsfw/housekeeping/HousekeepingMessage.h"
-#include "fsfw/ipc/MessageQueueSenderIF.h"
-#include "fsfw/serviceinterface.h"
-#include "localPoolDefinitions.h"
-
-class AccessPoolManagerIF;
-class ProvidesDataPoolSubscriptionIF;
-class LocalPoolDataSetBase;
-class LocalPoolObjectBase;
-
-/**
- * @brief 		This interface is implemented by classes which posses a local data pool (not
- * the managing class). It defines the relationship between the local data pool owner and the
- * LocalDataPoolManager.
- * @details
- * Any class implementing this interface shall also have a LocalDataPoolManager member class which
- * contains the actual pool data structure and exposes the public interface for it.
- *
- * The local data pool can be accessed using helper classes by using the
- * LocalPoolVariable, LocalPoolVector or LocalDataSet classes. Every local pool variable can
- * be uniquely identified by a global pool ID (gp_id_t) and every dataset tied
- * to a pool manager can be uniqely identified by a global structure ID (sid_t).
- *
- * All software objects which want to use the local pool of another object shall also use this
- * interface, for example to get a handle to the subscription interface. The interface
- * can be retrieved using the object manager, provided the target object is a SystemObject.
- * For example, the following line of code can be used to retrieve the interface
- *
- *    HasLocalDataPoolIF* poolIF = ObjectManager::instance()->
- *             get<HasLocalDataPoolIF>(objects::SOME_OBJECT);
- *    if(poolIF != nullptr) {
- *        doSomething()
- *    }
- */
-class HasLocalDataPoolIF {
-  friend class HasLocalDpIFManagerAttorney;
-  friend class HasLocalDpIFUserAttorney;
-
- public:
-  virtual ~HasLocalDataPoolIF() {};
-
-  static constexpr uint32_t INVALID_LPID = localpool::INVALID_LPID;
-
-  virtual object_id_t getObjectId() const = 0;
-
-  /** Command queue for housekeeping messages. */
-  virtual MessageQueueId_t getCommandQueue() const = 0;
-
-  /**
-   * Is used by pool owner to initialize the pool map once
-   * The manager instance shall also be passed to this function.
-   * It can be used to subscribe for periodic packets for for updates.
-   */
-  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                                LocalDataPoolManager& poolManager) = 0;
-
-  /**
-   * Returns the minimum sampling frequency in milliseconds, which will
-   * usually be the period the pool owner performs its periodic operation.
-   * @return
-   */
-  virtual dur_millis_t getPeriodicOperationFrequency() const = 0;
-
-  /**
-   * @brief   This function will be called by the manager if an update
-   *          notification is received.
-   * @details  HasLocalDataPoolIF
-   * Can be overriden by the child class to handle changed datasets.
-   * @param sid           SID of the updated set
-   * @param storeId       If a snapshot was requested, data will be located inside
-   * the IPC store with this store ID.
-   * @param clearMessage  If this is set to true, the pool manager will take care of
-   *                      clearing the store automatically
-   */
-  virtual void handleChangedDataset(sid_t sid, store_address_t storeId = store_address_t::invalid(),
-                                    bool* clearMessage = nullptr) {
-    if (clearMessage != nullptr) {
-      *clearMessage = true;
-    }
-  }
-
-  /**
-   * @brief   This function will be called by the manager if an update
-   *          notification is received.
-   * @details
-   * Can be overriden by the child class to handle changed pool variables.
-   * @param gpid          GPID of the updated variable.
-   * @param storeId       If a snapshot was requested, data will be located inside
-   * the IPC store with this store ID.
-   * @param clearMessage  Relevant for snapshots. If the boolean this points to is set to true,
-   *                      the pool manager will take care of clearing the store automatically
-   *                      after the callback.
-   */
-  virtual void handleChangedPoolVariable(gp_id_t gpid,
-                                         store_address_t storeId = store_address_t::invalid(),
-                                         bool* clearMessage = nullptr) {
-    if (clearMessage != nullptr) {
-      *clearMessage = true;
-    }
-  }
-
-  /**
-   * These function can be implemented by pool owner, if they are required
-   * and used by the housekeeping message interface.
-   * */
-  virtual ReturnValue_t addDataSet(sid_t sid) { return returnvalue::FAILED; };
-  virtual ReturnValue_t removeDataSet(sid_t sid) { return returnvalue::FAILED; };
-  virtual ReturnValue_t changeCollectionInterval(sid_t sid, float newIntervalSeconds) {
-    return returnvalue::FAILED;
-  };
-
-  /**
-   * This function can be used by data pool consumers to retrieve a handle
-   * which allows subscriptions to dataset and variable updates in form of messages.
-   * The consumers can then read the most recent variable value by calling read with
-   * an own pool variable or set instance or using the deserialized snapshot data.
-   * Returns the HK manager casted to the required interface by default.
-   * @return
-   */
-  virtual ProvidesDataPoolSubscriptionIF* getSubscriptionInterface() {
-    return getHkManagerHandle();
-  }
-
- protected:
-  /**
-   * Every class implementing this interface should have a local data pool manager. This
-   * function will return a reference to the manager.
-   * @return
-   */
-  virtual LocalDataPoolManager* getHkManagerHandle() = 0;
-
-  /**
-   * Accessor handle required for internal handling. Not intended for users and therefore
-   * declared protected. Users should instead use pool variables, sets or the subscription
-   * interface to access pool entries. Returns the HK manager casted to a different interface
-   * by default.
-   * @return
-   */
-  virtual AccessPoolManagerIF* getAccessorHandle() { return getHkManagerHandle(); }
-
-  /**
-   * This function is used by the pool manager to get a valid dataset
-   * from a SID. This function is protected to prevent users from
-   * using raw data set pointers which could not be thread-safe. Users
-   * should use the #ProvidesDataPoolSubscriptionIF.
-   * @param sid Corresponding structure ID
-   * @return
-   */
-  virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) = 0;
-
-  /**
-   * Similar to the function above, but used to get a local pool variable
-   * handle. This is only needed for update notifications, so it is not
-   * defined as abstract. This function is protected to prevent users from
-   * using raw pool variable pointers which could not be thread-safe.
-   * Users should use the #ProvidesDataPoolSubscriptionIF.
-   * @param localPoolId
-   * @return
-   */
-  virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "HasLocalDataPoolIF::getPoolObjectHandle: Not overriden. "
-                    "Returning nullptr!"
-                 << std::endl;
-#else
-    sif::printWarning(
-        "HasLocalDataPoolIF::getPoolObjectHandle: "
-        "Not overriden. Returning nullptr!\n");
-#endif
-    return nullptr;
-  }
-};
-
-#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDATAPOOLIF_H_ */
diff --git a/src/fsfw/datapoollocal/LocalDataPoolManager.cpp b/src/fsfw/datapoollocal/LocalDataPoolManager.cpp
deleted file mode 100644
index f851ebd2..00000000
--- a/src/fsfw/datapoollocal/LocalDataPoolManager.cpp
+++ /dev/null
@@ -1,817 +0,0 @@
-#include "fsfw/datapoollocal/LocalDataPoolManager.h"
-
-#include <cmath>
-
-#include "fsfw/datapoollocal.h"
-#include "fsfw/housekeeping/AcceptsHkPacketsIF.h"
-#include "fsfw/housekeeping/HousekeepingSetPacket.h"
-#include "fsfw/housekeeping/HousekeepingSnapshot.h"
-#include "fsfw/ipc/MutexFactory.h"
-#include "fsfw/ipc/MutexGuard.h"
-#include "fsfw/ipc/QueueFactory.h"
-#include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/timemanager/CCSDSTime.h"
-#include "internal/HasLocalDpIFManagerAttorney.h"
-#include "internal/LocalPoolDataSetAttorney.h"
-
-// TODO: Get rid of this. This should be a constructor argument, not something hardcoded in any way
-object_id_t LocalDataPoolManager::defaultHkDestination = objects::PUS_SERVICE_3_HOUSEKEEPING;
-
-LocalDataPoolManager::LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
-                                           bool appendValidityBuffer)
-    : appendValidityBuffer(appendValidityBuffer) {
-  if (owner == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "LocalDataPoolManager", returnvalue::FAILED,
-                        "Invalid supplied owner");
-    return;
-  }
-  this->owner = owner;
-  mutex = MutexFactory::instance()->createMutex();
-  if (mutex == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_ERROR, "LocalDataPoolManager", returnvalue::FAILED,
-                        "Could not create mutex");
-  }
-
-  hkQueue = queueToUse;
-}
-
-LocalDataPoolManager::~LocalDataPoolManager() {
-  if (mutex != nullptr) {
-    MutexFactory::instance()->deleteMutex(mutex);
-  }
-}
-
-ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
-  if (queueToUse == nullptr) {
-    /* Error, all destinations invalid */
-    printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", QUEUE_OR_DESTINATION_INVALID);
-  }
-  hkQueue = queueToUse;
-
-  ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
-  if (ipcStore == nullptr) {
-    /* Error, all destinations invalid */
-    printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", returnvalue::FAILED,
-                        "Could not set IPC store.");
-    return returnvalue::FAILED;
-  }
-
-  if (defaultHkDestination != objects::NO_OBJECT) {
-    auto* hkPacketReceiver =
-        ObjectManager::instance()->get<AcceptsHkPacketsIF>(defaultHkDestination);
-    if (hkPacketReceiver != nullptr) {
-      hkDestinationId = hkPacketReceiver->getHkQueue();
-    } else {
-      printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", QUEUE_OR_DESTINATION_INVALID);
-      return QUEUE_OR_DESTINATION_INVALID;
-    }
-  }
-
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalDataPoolManager::initializeAfterTaskCreation() {
-  return initializeHousekeepingPoolEntriesOnce();
-}
-
-ReturnValue_t LocalDataPoolManager::initializeHousekeepingPoolEntriesOnce() {
-  if (not mapInitialized) {
-    ReturnValue_t result = owner->initializeLocalDataPool(localPoolMap, *this);
-    if (result == returnvalue::OK) {
-      mapInitialized = true;
-    }
-    return result;
-  }
-
-  printWarningOrError(sif::OutputTypes::OUT_WARNING, "initializeHousekeepingPoolEntriesOnce",
-                      returnvalue::FAILED, "The map should only be initialized once");
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalDataPoolManager::performHkOperation() {
-  ReturnValue_t status = returnvalue::OK;
-  for (auto& receiver : hkReceivers) {
-    switch (receiver.reportingType) {
-      case (ReportingType::PERIODIC): {
-        if (receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-          /* Periodic packets shall only be generated from datasets */
-          continue;
-        }
-        performPeriodicHkGeneration(receiver);
-        break;
-      }
-      case (ReportingType::UPDATE_HK): {
-        handleHkUpdate(receiver, status);
-        break;
-      }
-      case (ReportingType::UPDATE_NOTIFICATION): {
-        handleNotificationUpdate(receiver, status);
-        break;
-      }
-      case (ReportingType::UPDATE_SNAPSHOT): {
-        handleNotificationSnapshot(receiver, status);
-        break;
-      }
-      default:
-        // This should never happen.
-        return returnvalue::FAILED;
-    }
-  }
-  resetHkUpdateResetHelper();
-  return status;
-}
-
-ReturnValue_t LocalDataPoolManager::handleHkUpdate(HkReceiver& receiver, ReturnValue_t& status) {
-  if (receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-    /* Update packets shall only be generated from datasets. */
-    return returnvalue::FAILED;
-  }
-  LocalPoolDataSetBase* dataSet =
-      HasLocalDpIFManagerAttorney::getDataSetHandle(owner, receiver.dataId.sid);
-  if (dataSet == nullptr) {
-    return DATASET_NOT_FOUND;
-  }
-  if (dataSet->hasChanged()) {
-    /* Prepare and send update notification */
-    ReturnValue_t result = generateHousekeepingPacket(receiver.dataId.sid, dataSet, true);
-    if (result != returnvalue::OK) {
-      status = result;
-    }
-  }
-  handleChangeResetLogic(receiver.dataType, receiver.dataId, dataSet);
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalDataPoolManager::handleNotificationUpdate(HkReceiver& receiver,
-                                                             ReturnValue_t& status) {
-  MarkChangedIF* toReset = nullptr;
-  if (receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-    LocalPoolObjectBase* poolObj =
-        HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner, receiver.dataId.localPoolId);
-    if (poolObj == nullptr) {
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleNotificationUpdate",
-                          POOLOBJECT_NOT_FOUND);
-      return POOLOBJECT_NOT_FOUND;
-    }
-    if (poolObj->hasChanged()) {
-      /* Prepare and send update notification. */
-      CommandMessage notification;
-      HousekeepingMessage::setUpdateNotificationVariableCommand(
-          &notification, gp_id_t(owner->getObjectId(), receiver.dataId.localPoolId));
-      ReturnValue_t result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
-      if (result != returnvalue::OK) {
-        status = result;
-      }
-      toReset = poolObj;
-    }
-
-  } else {
-    LocalPoolDataSetBase* dataSet =
-        HasLocalDpIFManagerAttorney::getDataSetHandle(owner, receiver.dataId.sid);
-    if (dataSet == nullptr) {
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleNotificationUpdate",
-                          DATASET_NOT_FOUND);
-      return DATASET_NOT_FOUND;
-    }
-    if (dataSet->hasChanged()) {
-      /* Prepare and send update notification */
-      CommandMessage notification;
-      HousekeepingMessage::setUpdateNotificationSetCommand(&notification, receiver.dataId.sid);
-      ReturnValue_t result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
-      if (result != returnvalue::OK) {
-        status = result;
-      }
-      toReset = dataSet;
-    }
-  }
-  if (toReset != nullptr) {
-    handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset);
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalDataPoolManager::handleNotificationSnapshot(HkReceiver& receiver,
-                                                               ReturnValue_t& status) {
-  MarkChangedIF* toReset = nullptr;
-  /* Check whether data has changed and send messages in case it has */
-  if (receiver.dataType == DataType::LOCAL_POOL_VARIABLE) {
-    LocalPoolObjectBase* poolObj =
-        HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner, receiver.dataId.localPoolId);
-    if (poolObj == nullptr) {
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleNotificationSnapshot",
-                          POOLOBJECT_NOT_FOUND);
-      return POOLOBJECT_NOT_FOUND;
-    }
-
-    if (not poolObj->hasChanged()) {
-      return returnvalue::OK;
-    }
-
-    /* Prepare and send update snapshot */
-    timeval now{};
-    Clock::getClock_timeval(&now);
-    CCSDSTime::CDS_short cds{};
-    CCSDSTime::convertToCcsds(&cds, &now);
-    HousekeepingSnapshot updatePacket(
-        reinterpret_cast<uint8_t*>(&cds), sizeof(cds),
-        HasLocalDpIFManagerAttorney::getPoolObjectHandle(owner, receiver.dataId.localPoolId));
-
-    store_address_t storeId;
-    ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-    if (result != returnvalue::OK) {
-      return result;
-    }
-
-    CommandMessage notification;
-    HousekeepingMessage::setUpdateSnapshotVariableCommand(
-        &notification, gp_id_t(owner->getObjectId(), receiver.dataId.localPoolId), storeId);
-    result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
-    if (result != returnvalue::OK) {
-      status = result;
-    }
-    toReset = poolObj;
-  } else {
-    LocalPoolDataSetBase* dataSet =
-        HasLocalDpIFManagerAttorney::getDataSetHandle(owner, receiver.dataId.sid);
-    if (dataSet == nullptr) {
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleNotificationSnapshot",
-                          DATASET_NOT_FOUND);
-      return DATASET_NOT_FOUND;
-    }
-
-    if (not dataSet->hasChanged()) {
-      return returnvalue::OK;
-    }
-
-    /* Prepare and send update snapshot */
-    timeval now{};
-    Clock::getClock_timeval(&now);
-    CCSDSTime::CDS_short cds{};
-    CCSDSTime::convertToCcsds(&cds, &now);
-    HousekeepingSnapshot updatePacket(
-        reinterpret_cast<uint8_t*>(&cds), sizeof(cds),
-        HasLocalDpIFManagerAttorney::getDataSetHandle(owner, receiver.dataId.sid));
-
-    store_address_t storeId;
-    ReturnValue_t result = addUpdateToStore(updatePacket, storeId);
-    if (result != returnvalue::OK) {
-      return result;
-    }
-
-    CommandMessage notification;
-    HousekeepingMessage::setUpdateSnapshotSetCommand(&notification, receiver.dataId.sid, storeId);
-    result = hkQueue->sendMessage(receiver.destinationQueue, &notification);
-    if (result != returnvalue::OK) {
-      status = result;
-    }
-    toReset = dataSet;
-  }
-  if (toReset != nullptr) {
-    handleChangeResetLogic(receiver.dataType, receiver.dataId, toReset);
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalDataPoolManager::addUpdateToStore(HousekeepingSnapshot& updatePacket,
-                                                     store_address_t& storeId) {
-  size_t updatePacketSize = updatePacket.getSerializedSize();
-  uint8_t* storePtr = nullptr;
-  ReturnValue_t result =
-      ipcStore->getFreeElement(&storeId, updatePacket.getSerializedSize(), &storePtr);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  size_t serializedSize = 0;
-  result = updatePacket.serialize(&storePtr, &serializedSize, updatePacketSize,
-                                  SerializeIF::Endianness::MACHINE);
-  return result;
-  ;
-}
-
-void LocalDataPoolManager::handleChangeResetLogic(DataType type, DataId dataId,
-                                                  MarkChangedIF* toReset) {
-  for (auto& changeInfo : hkUpdateResetList) {
-    if (changeInfo.dataType != type) {
-      continue;
-    }
-    if ((changeInfo.dataType == DataType::DATA_SET) and (changeInfo.dataId.sid != dataId.sid)) {
-      continue;
-    }
-    if ((changeInfo.dataType == DataType::LOCAL_POOL_VARIABLE) and
-        (changeInfo.dataId.localPoolId != dataId.localPoolId)) {
-      continue;
-    }
-
-    /* Only one update recipient, we can reset changes status immediately */
-    if (changeInfo.updateCounter <= 1) {
-      toReset->setChanged(false);
-    }
-    /* All recipients have been notified, reset the changed flag */
-    else if (changeInfo.currentUpdateCounter <= 1) {
-      toReset->setChanged(false);
-      changeInfo.currentUpdateCounter = 0;
-    }
-    /* Not all recipiens have been notified yet, decrement */
-    else {
-      changeInfo.currentUpdateCounter--;
-    }
-    return;
-  }
-}
-
-void LocalDataPoolManager::resetHkUpdateResetHelper() {
-  for (auto& changeInfo : hkUpdateResetList) {
-    changeInfo.currentUpdateCounter = changeInfo.updateCounter;
-  }
-}
-
-ReturnValue_t LocalDataPoolManager::subscribeForRegularPeriodicPacket(
-    subdp::RegularHkPeriodicParams params) {
-  return subscribeForPeriodicPacket(params);
-}
-
-ReturnValue_t LocalDataPoolManager::subscribeForDiagPeriodicPacket(
-    subdp::DiagnosticsHkPeriodicParams params) {
-  return subscribeForPeriodicPacket(params);
-}
-
-ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(subdp::ParamsBase& params) {
-  struct HkReceiver hkReceiver;
-  hkReceiver.dataId.sid = params.sid;
-  hkReceiver.reportingType = ReportingType::PERIODIC;
-  hkReceiver.dataType = DataType::DATA_SET;
-  if (params.receiver == MessageQueueIF::NO_QUEUE) {
-    hkReceiver.destinationQueue = hkDestinationId;
-  } else {
-    hkReceiver.destinationQueue = params.receiver;
-  }
-
-  LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, params.sid);
-  if (dataSet != nullptr) {
-    LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, params.enableReporting);
-    LocalPoolDataSetAttorney::initializePeriodicHelper(*dataSet, params.collectionInterval,
-                                                       owner->getPeriodicOperationFrequency());
-  }
-
-  hkReceivers.push_back(hkReceiver);
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalDataPoolManager::subscribeForRegularUpdatePacket(
-    subdp::RegularHkUpdateParams params) {
-  return subscribeForUpdatePacket(params);
-}
-ReturnValue_t LocalDataPoolManager::subscribeForDiagUpdatePacket(
-    subdp::DiagnosticsHkUpdateParams params) {
-  return subscribeForUpdatePacket(params);
-}
-
-ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(subdp::ParamsBase& params) {
-  struct HkReceiver hkReceiver;
-  hkReceiver.dataId.sid = params.sid;
-  hkReceiver.reportingType = ReportingType::UPDATE_HK;
-  hkReceiver.dataType = DataType::DATA_SET;
-  if (params.receiver == MessageQueueIF::NO_QUEUE) {
-    hkReceiver.destinationQueue = hkDestinationId;
-  } else {
-    hkReceiver.destinationQueue = params.receiver;
-  }
-
-  LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, params.sid);
-  if (dataSet != nullptr) {
-    LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, true);
-  }
-
-  hkReceivers.push_back(hkReceiver);
-
-  handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalDataPoolManager::subscribeForSetUpdateMessage(const uint32_t setId,
-                                                                 object_id_t destinationObject,
-                                                                 MessageQueueId_t targetQueueId,
-                                                                 bool generateSnapshot) {
-  struct HkReceiver hkReceiver;
-  hkReceiver.dataType = DataType::DATA_SET;
-  hkReceiver.dataId.sid = sid_t(owner->getObjectId(), setId);
-  hkReceiver.destinationQueue = targetQueueId;
-  hkReceiver.objectId = destinationObject;
-  if (generateSnapshot) {
-    hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
-  } else {
-    hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
-  }
-
-  hkReceivers.push_back(hkReceiver);
-
-  handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalDataPoolManager::subscribeForVariableUpdateMessage(
-    const lp_id_t localPoolId, object_id_t destinationObject, MessageQueueId_t targetQueueId,
-    bool generateSnapshot) {
-  struct HkReceiver hkReceiver;
-  hkReceiver.dataType = DataType::LOCAL_POOL_VARIABLE;
-  hkReceiver.dataId.localPoolId = localPoolId;
-  hkReceiver.destinationQueue = targetQueueId;
-  hkReceiver.objectId = destinationObject;
-  if (generateSnapshot) {
-    hkReceiver.reportingType = ReportingType::UPDATE_SNAPSHOT;
-  } else {
-    hkReceiver.reportingType = ReportingType::UPDATE_NOTIFICATION;
-  }
-
-  hkReceivers.push_back(hkReceiver);
-
-  handleHkUpdateResetListInsertion(hkReceiver.dataType, hkReceiver.dataId);
-  return returnvalue::OK;
-}
-
-void LocalDataPoolManager::handleHkUpdateResetListInsertion(DataType dataType, DataId dataId) {
-  for (auto& updateResetStruct : hkUpdateResetList) {
-    if (dataType == DataType::DATA_SET) {
-      if (updateResetStruct.dataId.sid == dataId.sid) {
-        updateResetStruct.updateCounter++;
-        updateResetStruct.currentUpdateCounter++;
-        return;
-      }
-    } else {
-      if (updateResetStruct.dataId.localPoolId == dataId.localPoolId) {
-        updateResetStruct.updateCounter++;
-        updateResetStruct.currentUpdateCounter++;
-        return;
-      }
-    }
-  }
-  HkUpdateResetHelper hkUpdateResetHelper;
-  hkUpdateResetHelper.currentUpdateCounter = 1;
-  hkUpdateResetHelper.updateCounter = 1;
-  hkUpdateResetHelper.dataType = dataType;
-  if (dataType == DataType::DATA_SET) {
-    hkUpdateResetHelper.dataId.sid = dataId.sid;
-  } else {
-    hkUpdateResetHelper.dataId.localPoolId = dataId.localPoolId;
-  }
-  hkUpdateResetList.push_back(hkUpdateResetHelper);
-}
-
-ReturnValue_t LocalDataPoolManager::handleHousekeepingMessage(CommandMessage* message) {
-  Command_t command = message->getCommand();
-  sid_t sid = HousekeepingMessage::getSid(message);
-  ReturnValue_t result = returnvalue::OK;
-  switch (command) {
-    // Houskeeping interface handling.
-    case (HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
-      result = togglePeriodicGeneration(sid, true);
-      break;
-    }
-
-    case (HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
-      result = togglePeriodicGeneration(sid, false);
-      break;
-    }
-
-    case (HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): {
-      result = generateSetStructurePacket(sid);
-      if (result == returnvalue::OK) {
-        return result;
-      }
-      break;
-    }
-    case (HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
-      float newCollIntvl = 0;
-      HousekeepingMessage::getCollectionIntervalModificationCommand(message, &newCollIntvl);
-      result = changeCollectionInterval(sid, newCollIntvl);
-      break;
-    }
-
-    case (HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT): {
-      LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-      if (dataSet == nullptr) {
-        printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleHousekeepingMessage",
-                            DATASET_NOT_FOUND);
-        return DATASET_NOT_FOUND;
-      }
-      return generateHousekeepingPacket(HousekeepingMessage::getSid(message), dataSet, true);
-    }
-
-    /* Notification handling */
-    case (HousekeepingMessage::UPDATE_NOTIFICATION_SET): {
-      owner->handleChangedDataset(sid);
-      return returnvalue::OK;
-    }
-    case (HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE): {
-      gp_id_t globPoolId = HousekeepingMessage::getUpdateNotificationVariableCommand(message);
-      owner->handleChangedPoolVariable(globPoolId);
-      return returnvalue::OK;
-    }
-    case (HousekeepingMessage::UPDATE_SNAPSHOT_SET): {
-      store_address_t storeId;
-      HousekeepingMessage::getUpdateSnapshotSetCommand(message, &storeId);
-      bool clearMessage = true;
-      owner->handleChangedDataset(sid, storeId, &clearMessage);
-      if (clearMessage) {
-        message->clear();
-      }
-      return returnvalue::OK;
-    }
-    case (HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE): {
-      store_address_t storeId;
-      gp_id_t globPoolId = HousekeepingMessage::getUpdateSnapshotVariableCommand(message, &storeId);
-      bool clearMessage = true;
-      owner->handleChangedPoolVariable(globPoolId, storeId, &clearMessage);
-      if (clearMessage) {
-        message->clear();
-      }
-      return returnvalue::OK;
-    }
-
-    default:
-      return CommandMessageIF::UNKNOWN_COMMAND;
-  }
-
-  CommandMessage reply;
-  if (result != returnvalue::OK) {
-    if (result == WRONG_HK_PACKET_TYPE) {
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleHousekeepingMessage",
-                          WRONG_HK_PACKET_TYPE);
-    }
-    HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
-  } else {
-    HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
-  }
-  hkQueue->sendMessage(hkDestinationId, &reply);
-  return result;
-}
-
-ReturnValue_t LocalDataPoolManager::printPoolEntry(lp_id_t localPoolId) {
-  auto poolIter = localPoolMap.find(localPoolId);
-  if (poolIter == localPoolMap.end()) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "printPoolEntry",
-                        localpool::POOL_ENTRY_NOT_FOUND);
-    return localpool::POOL_ENTRY_NOT_FOUND;
-  }
-  poolIter->second->print();
-  return returnvalue::OK;
-}
-
-MutexIF* LocalDataPoolManager::getMutexHandle() { return mutex; }
-
-HasLocalDataPoolIF* LocalDataPoolManager::getOwner() { return owner; }
-
-ReturnValue_t LocalDataPoolManager::generateHousekeepingPacket(sid_t sid,
-                                                               LocalPoolDataSetBase* dataSet,
-                                                               bool forDownlink,
-                                                               MessageQueueId_t destination) {
-  if (dataSet == nullptr) {
-    /* Configuration error. */
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket",
-                        DATASET_NOT_FOUND);
-    return DATASET_NOT_FOUND;
-  }
-
-  store_address_t storeId;
-  HousekeepingPacketDownlink hkPacket(sid, dataSet);
-  size_t serializedSize = 0;
-  ReturnValue_t result =
-      serializeHkPacketIntoStore(hkPacket, storeId, forDownlink, &serializedSize);
-  if (result != returnvalue::OK or serializedSize == 0) {
-    return result;
-  }
-
-  /* Now we set a HK message and send it the HK packet destination. */
-  CommandMessage hkMessage;
-  HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
-
-  if (hkQueue == nullptr) {
-    /* Error, no queue available to send packet with. */
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket",
-                        QUEUE_OR_DESTINATION_INVALID);
-    return QUEUE_OR_DESTINATION_INVALID;
-  }
-  if (destination == MessageQueueIF::NO_QUEUE) {
-    if (hkDestinationId == MessageQueueIF::NO_QUEUE) {
-      /* Error, all destinations invalid */
-      printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket",
-                          QUEUE_OR_DESTINATION_INVALID);
-      return QUEUE_OR_DESTINATION_INVALID;
-    }
-    destination = hkDestinationId;
-  }
-
-  return hkQueue->sendMessage(destination, &hkMessage);
-}
-
-ReturnValue_t LocalDataPoolManager::serializeHkPacketIntoStore(HousekeepingPacketDownlink& hkPacket,
-                                                               store_address_t& storeId,
-                                                               bool forDownlink,
-                                                               size_t* serializedSize) {
-  uint8_t* dataPtr = nullptr;
-  const size_t maxSize = hkPacket.getSerializedSize();
-  ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize, &dataPtr);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-
-  if (forDownlink) {
-    return hkPacket.serialize(&dataPtr, serializedSize, maxSize, SerializeIF::Endianness::BIG);
-  }
-  return hkPacket.serialize(&dataPtr, serializedSize, maxSize, SerializeIF::Endianness::MACHINE);
-}
-
-void LocalDataPoolManager::performPeriodicHkGeneration(HkReceiver& receiver) {
-  sid_t sid = receiver.dataId.sid;
-  LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-  if (dataSet == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "performPeriodicHkGeneration",
-                        DATASET_NOT_FOUND);
-    return;
-  }
-
-  if (not LocalPoolDataSetAttorney::getReportingEnabled(*dataSet)) {
-    return;
-  }
-
-  PeriodicHousekeepingHelper* periodicHelper =
-      LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
-
-  if (periodicHelper == nullptr) {
-    /* Configuration error */
-    return;
-  }
-
-  if (not periodicHelper->checkOpNecessary()) {
-    return;
-  }
-
-  ReturnValue_t result = generateHousekeepingPacket(sid, dataSet, true);
-  if (result != returnvalue::OK) {
-    /* Configuration error */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed."
-                 << std::endl;
-#else
-    sif::printWarning("LocalDataPoolManager::performPeriodicHkOperation: HK generation failed.\n");
-#endif
-  }
-}
-
-ReturnValue_t LocalDataPoolManager::togglePeriodicGeneration(sid_t sid, bool enable) {
-  LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-  if (dataSet == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "togglePeriodicGeneration",
-                        DATASET_NOT_FOUND);
-    return DATASET_NOT_FOUND;
-  }
-
-  if ((LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and enable) or
-      (not LocalPoolDataSetAttorney::getReportingEnabled(*dataSet) and not enable)) {
-    return returnvalue::OK;
-  }
-
-  LocalPoolDataSetAttorney::setReportingEnabled(*dataSet, enable);
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalDataPoolManager::changeCollectionInterval(sid_t sid,
-                                                             float newCollectionInterval) {
-  LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-  if (dataSet == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "changeCollectionInterval",
-                        DATASET_NOT_FOUND);
-    return DATASET_NOT_FOUND;
-  }
-
-  PeriodicHousekeepingHelper* periodicHelper =
-      LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet);
-
-  if (periodicHelper == nullptr) {
-    /* Configuration error, set might not have a corresponding pool manager */
-    return PERIODIC_HELPER_INVALID;
-  }
-
-  periodicHelper->changeCollectionInterval(newCollectionInterval);
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalDataPoolManager::generateSetStructurePacket(sid_t sid) {
-  /* Get and check dataset first. */
-  LocalPoolDataSetBase* dataSet = HasLocalDpIFManagerAttorney::getDataSetHandle(owner, sid);
-  if (dataSet == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "performPeriodicHkGeneration",
-                        DATASET_NOT_FOUND);
-    return DATASET_NOT_FOUND;
-  }
-
-  bool valid = dataSet->isValid();
-  bool reportingEnabled = LocalPoolDataSetAttorney::getReportingEnabled(*dataSet);
-  float collectionInterval =
-      LocalPoolDataSetAttorney::getPeriodicHelper(*dataSet)->getCollectionIntervalInSeconds();
-
-  // Generate set packet which can be serialized.
-  HousekeepingSetPacket setPacket(sid, reportingEnabled, valid, collectionInterval, dataSet);
-  size_t expectedSize = setPacket.getSerializedSize();
-  uint8_t* storePtr = nullptr;
-  store_address_t storeId;
-  ReturnValue_t result = ipcStore->getFreeElement(&storeId, expectedSize, &storePtr);
-  if (result != returnvalue::OK) {
-    printWarningOrError(sif::OutputTypes::OUT_ERROR, "generateSetStructurePacket",
-                        returnvalue::FAILED, "Could not get free element from IPC store.");
-    return result;
-  }
-
-  // Serialize set packet into store.
-  size_t size = 0;
-  result = setPacket.serialize(&storePtr, &size, expectedSize, SerializeIF::Endianness::BIG);
-  if (result != returnvalue::OK) {
-    ipcStore->deleteData(storeId);
-    return result;
-  }
-  if (expectedSize != size) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateSetStructurePacket",
-                        returnvalue::FAILED, "Expected size is not equal to serialized size");
-  }
-
-  // Send structure reporting reply.
-  CommandMessage reply;
-  HousekeepingMessage::setHkStuctureReportReply(&reply, sid, storeId);
-
-  result = hkQueue->reply(&reply);
-  if (result != returnvalue::OK) {
-    ipcStore->deleteData(storeId);
-  }
-  return result;
-}
-
-void LocalDataPoolManager::clearReceiversList() {
-  /* Clear the vector completely and releases allocated memory. */
-  HkReceivers().swap(hkReceivers);
-  /* Also clear the reset helper if it exists */
-  HkUpdateResetList().swap(hkUpdateResetList);
-}
-
-MutexIF* LocalDataPoolManager::getLocalPoolMutex() { return this->mutex; }
-
-object_id_t LocalDataPoolManager::getCreatorObjectId() const { return owner->getObjectId(); }
-
-void LocalDataPoolManager::printWarningOrError(sif::OutputTypes outputType,
-                                               const char* functionName, ReturnValue_t error,
-                                               const char* errorPrint) {
-#if FSFW_VERBOSE_LEVEL >= 1
-  if (errorPrint == nullptr) {
-    if (error == DATASET_NOT_FOUND) {
-      errorPrint = "Dataset not found";
-    } else if (error == POOLOBJECT_NOT_FOUND) {
-      errorPrint = "Pool Object not found";
-    } else if (error == WRONG_HK_PACKET_TYPE) {
-      errorPrint = "Wrong Packet Type";
-    } else if (error == returnvalue::FAILED) {
-      if (outputType == sif::OutputTypes::OUT_WARNING) {
-        errorPrint = "Generic Warning";
-      } else {
-        errorPrint = "Generic error";
-      }
-    } else if (error == QUEUE_OR_DESTINATION_INVALID) {
-      errorPrint = "Queue or destination not set";
-    } else if (error == localpool::POOL_ENTRY_TYPE_CONFLICT) {
-      errorPrint = "Pool entry type conflict";
-    } else if (error == localpool::POOL_ENTRY_NOT_FOUND) {
-      errorPrint = "Pool entry not found";
-    } else {
-      errorPrint = "Unknown error";
-    }
-  }
-  object_id_t objectId = 0xffffffff;
-  if (owner != nullptr) {
-    objectId = owner->getObjectId();
-  }
-
-  if (outputType == sif::OutputTypes::OUT_WARNING) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "LocalDataPoolManager::" << functionName << ": Object ID 0x" << std::setw(8)
-                 << std::setfill('0') << std::hex << objectId << " | " << errorPrint << std::dec
-                 << std::setfill(' ') << std::endl;
-#else
-    sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n", functionName, objectId,
-                      errorPrint);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-  } else if (outputType == sif::OutputTypes::OUT_ERROR) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "LocalDataPoolManager::" << functionName << ": Object ID 0x" << std::setw(8)
-               << std::setfill('0') << std::hex << objectId << " | " << errorPrint << std::dec
-               << std::setfill(' ') << std::endl;
-#else
-    sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n", functionName, objectId,
-                    errorPrint);
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-  }
-#endif /* #if FSFW_VERBOSE_LEVEL >= 1 */
-}
-
-LocalDataPoolManager* LocalDataPoolManager::getPoolManagerHandle() { return this; }
-
-void LocalDataPoolManager::setHkDestinationId(MessageQueueId_t hkDestId) {
-  hkDestinationId = hkDestId;
-}
diff --git a/src/fsfw/datapoollocal/LocalDataPoolManager.h b/src/fsfw/datapoollocal/LocalDataPoolManager.h
deleted file mode 100644
index 56deac3d..00000000
--- a/src/fsfw/datapoollocal/LocalDataPoolManager.h
+++ /dev/null
@@ -1,380 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
-#define FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_
-
-#include <map>
-#include <vector>
-
-#include "AccessLocalPoolF.h"
-#include "ProvidesDataPoolSubscriptionIF.h"
-#include "fsfw/datapool/DataSetIF.h"
-#include "fsfw/datapool/PoolEntry.h"
-#include "fsfw/housekeeping/AcceptsHkPacketsIF.h"
-#include "fsfw/housekeeping/HousekeepingMessage.h"
-#include "fsfw/housekeeping/HousekeepingPacketDownlink.h"
-#include "fsfw/housekeeping/PeriodicHousekeepingHelper.h"
-#include "fsfw/ipc/CommandMessage.h"
-#include "fsfw/ipc/MessageQueueIF.h"
-#include "fsfw/ipc/MutexGuard.h"
-#include "fsfw/ipc/MutexIF.h"
-#include "fsfw/objectmanager/SystemObjectIF.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
-
-namespace Factory {
-void setStaticFrameworkObjectIds();
-}
-
-class LocalPoolDataSetBase;
-class HousekeepingSnapshot;
-class HasLocalDataPoolIF;
-class LocalDataPool;
-
-/**
- * @brief 		This class is the managing instance for the local data pool.
- * @details
- * The actual data pool structure is a member of this class. Any class which
- * has a local data pool shall have this manager class as a member and implement
- * the HasLocalDataPoolIF.
- *
- * The manager offers some adaption points and functions which can be used
- * by the owning class to simplify data handling significantly.
- *
- * Please ensure that both initialize and initializeAfterTaskCreation are
- * called at some point by the owning class in the respective functions of the
- * same name!
- *
- * Users of the data pool use the helper classes LocalDataSet,
- * LocalPoolVariable and LocalPoolVector to access pool entries in
- * a thread-safe and efficient way.
- *
- * The local data pools employ a blackboard logic: Only the most recent
- * value is stored. The helper classes offer a read() and commit() interface
- * through the PoolVariableIF which is used to read and update values.
- * Each pool entry has a valid state too.
- * @author 		R. Mueller
- */
-class LocalDataPoolManager : public ProvidesDataPoolSubscriptionIF, public AccessPoolManagerIF {
-  friend void(Factory::setStaticFrameworkObjectIds)();
-  //! Some classes using the pool manager directly need to access class internals of the
-  //! manager. The attorney provides granular control of access to these internals.
-  friend class LocalDpManagerAttorney;
-
- public:
-  static constexpr uint8_t INTERFACE_ID = CLASS_ID::HOUSEKEEPING_MANAGER;
-
-  static constexpr ReturnValue_t QUEUE_OR_DESTINATION_INVALID = MAKE_RETURN_CODE(0);
-  static constexpr ReturnValue_t WRONG_HK_PACKET_TYPE = MAKE_RETURN_CODE(1);
-  static constexpr ReturnValue_t REPORTING_STATUS_UNCHANGED = MAKE_RETURN_CODE(2);
-  static constexpr ReturnValue_t PERIODIC_HELPER_INVALID = MAKE_RETURN_CODE(3);
-  static constexpr ReturnValue_t POOLOBJECT_NOT_FOUND = MAKE_RETURN_CODE(4);
-  static constexpr ReturnValue_t DATASET_NOT_FOUND = MAKE_RETURN_CODE(5);
-
-  /**
-   * This constructor is used by a class which wants to implement
-   * a personal local data pool. The queueToUse can be supplied if it
-   * is already known.
-   *
-   * initialize() has to be called in any case before using the object!
-   * @param owner
-   * @param queueToUse
-   * @param appendValidityBuffer Specify whether a buffer containing the
-   * validity state is generated  when serializing or deserializing packets.
-   */
-  LocalDataPoolManager(HasLocalDataPoolIF* owner, MessageQueueIF* queueToUse,
-                       bool appendValidityBuffer = true);
-  ~LocalDataPoolManager() override;
-
-  void setHkDestinationId(MessageQueueId_t hkDestId);
-
-  /**
-   * Assigns the queue to use. Make sure to call this in the #initialize
-   * function of the owner.
-   * @param queueToUse
-   * @param nonDiagInvlFactor See #setNonDiagnosticIntervalFactor doc
-   * @return
-   */
-  ReturnValue_t initialize(MessageQueueIF* queueToUse);
-
-  /**
-   * Initializes the map by calling the map initialization function and
-   * setting the periodic factor for non-diagnostic packets.
-   * Don't forget to call this in the #initializeAfterTaskCreation call of
-   * the owner, otherwise the map will be invalid!
-   * @param nonDiagInvlFactor
-   * @return
-   */
-  ReturnValue_t initializeAfterTaskCreation();
-
-  /**
-   * @brief   This should be called in the periodic handler of the owner.
-   * @details
-   * This in generally called in the #performOperation function of the owner.
-   * It performs all the periodic functionalities of the data pool manager,
-   * for example generating periodic HK packets.
-   * Marked virtual as an adaption point for custom data pool managers.
-   * @return
-   */
-  virtual ReturnValue_t performHkOperation();
-
-  /**
-   * @brief   Subscribe for a notification message which will be sent
-   *          if a dataset has changed.
-   * @details
-   * This subscription mechanism will generally be used internally by
-   * other software components.
-   * @param setId     Set ID of the set to receive update messages from.
-   * @param destinationObject
-   * @param targetQueueId
-   * @param generateSnapshot If this is set to true, a copy of the current
-   * data with a timestamp will be generated and sent via message.
-   * Otherwise, only an notification message is sent.
-   * @return
-   */
-  ReturnValue_t subscribeForSetUpdateMessage(uint32_t setId, object_id_t destinationObject,
-                                             MessageQueueId_t targetQueueId,
-                                             bool generateSnapshot) override;
-
-  /**
-   * @brief   Subscribe for an notification message which will be sent if a
-   *          pool variable has changed.
-   * @details
-   * This subscription mechanism will generally be used internally by
-   * other software components.
-   * @param localPoolId Pool ID of the pool variable
-   * @param destinationObject
-   * @param targetQueueId
-   * @param generateSnapshot If this is set to true, a copy of the current
-   * data with a timestamp will be generated and sent via message.
-   * Otherwise, only an notification message is sent.
-   * @return
-   */
-  ReturnValue_t subscribeForVariableUpdateMessage(lp_id_t localPoolId,
-                                                  object_id_t destinationObject,
-                                                  MessageQueueId_t targetQueueId,
-                                                  bool generateSnapshot) override;
-
-  /**
-   * @brief   The manager is also able to handle housekeeping messages.
-   * @details
-   * This most commonly is used to handle messages for the housekeeping
-   * interface, but the manager is also able to handle update notifications
-   * and calls a special function which can be overriden by a child class
-   * to handle data set or pool variable updates. This is relevant
-   * for classes like controllers which have their own local datapool
-   * but pull their data from other local datapools.
-   * @param message
-   * @return
-   */
-  virtual ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
-
-  /**
-   * Generate a housekeeping packet with a given SID.
-   * @param sid
-   * @return
-   */
-  ReturnValue_t generateHousekeepingPacket(sid_t sid, LocalPoolDataSetBase* dataSet,
-                                           bool forDownlink,
-                                           MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
-  ReturnValue_t changeCollectionInterval(sid_t sid, float newCollectionInterval);
-
-  HasLocalDataPoolIF* getOwner();
-
-  ReturnValue_t printPoolEntry(lp_id_t localPoolId);
-
-  /**
-   * Different types of housekeeping reporting are possible.
-   *  1. PERIODIC:
-   *     HK packets are generated in fixed intervals and sent to
-   *     destination. Fromat will be raw.
-   *  2. UPDATE_NOTIFICATION:
-   *     Notification will be sent out if HK data has changed.
-   *  3. UPDATE_SNAPSHOT:
-   *     HK packets are only generated if explicitely requested.
-   *     Propably not necessary, just use multiple local data sets or
-   *     shared datasets.
-   */
-  enum class ReportingType : uint8_t {
-    //! Periodic generation of HK packets.
-    PERIODIC,
-    //! Housekeeping packet will be generated if values have changed.
-    UPDATE_HK,
-    //! Update notification will be sent out as message.
-    UPDATE_NOTIFICATION,
-    //! Notification will be sent out as message and a snapshot of the
-    //! current data will be generated.
-    UPDATE_SNAPSHOT,
-  };
-
-  /** Different data types are possible in the HK receiver map. For example, updates can be
-  requested for full datasets or for single pool variables. Periodic reporting is only possible
-  for data sets. */
-  enum class DataType : uint8_t { LOCAL_POOL_VARIABLE, DATA_SET };
-
-  /* Copying forbidden */
-  LocalDataPoolManager(const LocalDataPoolManager&) = delete;
-  LocalDataPoolManager operator=(const LocalDataPoolManager&) = delete;
-
-  /**
-   * This function can be used to clear the receivers list. This is
-   * intended for test functions and not for regular operations, because
-   * the insertion operations allocate dynamically.
-   */
-  void clearReceiversList();
-
-  [[nodiscard]] object_id_t getCreatorObjectId() const;
-
-  /**
-   * Get the pointer to the mutex. Can be used to lock the data pool
-   * externally. Use with care and don't forget to unlock locked mutexes!
-   * For now, only friend classes can accss this function.
-   * @return
-   */
-  MutexIF* getMutexHandle();
-
-  LocalDataPoolManager* getPoolManagerHandle() override;
-  ReturnValue_t subscribeForRegularPeriodicPacket(subdp::RegularHkPeriodicParams params) override;
-  ReturnValue_t subscribeForDiagPeriodicPacket(subdp::DiagnosticsHkPeriodicParams params) override;
-
-  ReturnValue_t subscribeForRegularUpdatePacket(subdp::RegularHkUpdateParams params) override;
-  ReturnValue_t subscribeForDiagUpdatePacket(subdp::DiagnosticsHkUpdateParams params) override;
-
- protected:
-  ReturnValue_t subscribeForPeriodicPacket(subdp::ParamsBase& params);
-  ReturnValue_t subscribeForUpdatePacket(subdp::ParamsBase& params);
-
-  /** Core data structure for the actual pool data */
-  localpool::DataPool localPoolMap;
-  /** Every housekeeping data manager has a mutex to protect access
-  to it's data pool. */
-  MutexIF* mutex = nullptr;
-
-  /** The class which actually owns the manager (and its datapool). */
-  HasLocalDataPoolIF* owner = nullptr;
-
-  uint8_t nonDiagnosticIntervalFactor = 0;
-
-  /** Default receiver for periodic HK packets */
-  static object_id_t defaultHkDestination;
-  MessageQueueId_t hkDestinationId = MessageQueueIF::NO_QUEUE;
-
-  union DataId {
-    DataId() : sid() {};
-    sid_t sid;
-    lp_id_t localPoolId;
-  };
-
-  /** The data pool manager will keep an internal map of HK receivers. */
-  struct HkReceiver {
-    /** Object ID of receiver */
-    object_id_t objectId = objects::NO_OBJECT;
-
-    DataType dataType = DataType::DATA_SET;
-    DataId dataId;
-
-    ReportingType reportingType = ReportingType::PERIODIC;
-    MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
-  };
-
-  /** This vector will contain the list of HK receivers. */
-  using HkReceivers = std::vector<struct HkReceiver>;
-
-  HkReceivers hkReceivers;
-
-  struct HkUpdateResetHelper {
-    DataType dataType = DataType::DATA_SET;
-    DataId dataId;
-    uint8_t updateCounter;
-    uint8_t currentUpdateCounter;
-  };
-
-  using HkUpdateResetList = std::vector<struct HkUpdateResetHelper>;
-  /** This list is used to manage creating multiple update packets and only resetting
-  the update flag if all of them were created. */
-  HkUpdateResetList hkUpdateResetList = HkUpdateResetList();
-
-  /** This is the map holding the actual data. Should only be initialized
-   * once ! */
-  bool mapInitialized = false;
-  /** This specifies whether a validity buffer is appended at the end
-   * of generated housekeeping packets. */
-  bool appendValidityBuffer = true;
-
-  /**
-   * @brief Queue used for communication, for example commands.
-   * Is also used to send messages. Can be set either in the constructor
-   * or in the initialize() function.
-   */
-  MessageQueueIF* hkQueue = nullptr;
-
-  /** Global IPC store is used to store all packets. */
-  StorageManagerIF* ipcStore = nullptr;
-
-  /**
-   * Read a variable by supplying its local pool ID and assign the pool
-   * entry to the supplied PoolEntry pointer. The type of the pool entry
-   * is deduced automatically. This call is not thread-safe!
-   * For now, only classes designated by the LocalDpManagerAttorney may use this function.
-   * @tparam T Type of the pool entry
-   * @param localPoolId Pool ID of the variable to read
-   * @param poolVar [out] Corresponding pool entry will be assigned to the
-   * 						supplied pointer.
-   * @return
-   */
-  template <class T>
-  ReturnValue_t fetchPoolEntry(lp_id_t localPoolId, PoolEntry<T>** poolEntry);
-
-  /**
-   * This function is used to fill the local data pool map with pool
-   * entries. It should only be called once by the pool owner.
-   * @param localDataPoolMap
-   * @return
-   */
-  ReturnValue_t initializeHousekeepingPoolEntriesOnce();
-
-  MutexIF* getLocalPoolMutex() override;
-
-  ReturnValue_t serializeHkPacketIntoStore(HousekeepingPacketDownlink& hkPacket,
-                                           store_address_t& storeId, bool forDownlink,
-                                           size_t* serializedSize);
-
-  void performPeriodicHkGeneration(HkReceiver& hkReceiver);
-  ReturnValue_t togglePeriodicGeneration(sid_t sid, bool enable);
-  ReturnValue_t generateSetStructurePacket(sid_t sid);
-
-  void handleHkUpdateResetListInsertion(DataType dataType, DataId dataId);
-  void handleChangeResetLogic(DataType type, DataId dataId, MarkChangedIF* toReset);
-  void resetHkUpdateResetHelper();
-
-  ReturnValue_t handleHkUpdate(HkReceiver& hkReceiver, ReturnValue_t& status);
-  ReturnValue_t handleNotificationUpdate(HkReceiver& hkReceiver, ReturnValue_t& status);
-  ReturnValue_t handleNotificationSnapshot(HkReceiver& hkReceiver, ReturnValue_t& status);
-  ReturnValue_t addUpdateToStore(HousekeepingSnapshot& updatePacket, store_address_t& storeId);
-
-  void printWarningOrError(sif::OutputTypes outputType, const char* functionName,
-                           ReturnValue_t errorCode = returnvalue::FAILED,
-                           const char* errorPrint = nullptr);
-};
-
-template <class T>
-inline ReturnValue_t LocalDataPoolManager::fetchPoolEntry(lp_id_t localPoolId,
-                                                          PoolEntry<T>** poolEntry) {
-  if (poolEntry == nullptr) {
-    return returnvalue::FAILED;
-  }
-
-  auto poolIter = localPoolMap.find(localPoolId);
-  if (poolIter == localPoolMap.end()) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "fetchPoolEntry",
-                        localpool::POOL_ENTRY_NOT_FOUND);
-    return localpool::POOL_ENTRY_NOT_FOUND;
-  }
-
-  *poolEntry = dynamic_cast<PoolEntry<T>*>(poolIter->second);
-  if (*poolEntry == nullptr) {
-    printWarningOrError(sif::OutputTypes::OUT_WARNING, "fetchPoolEntry",
-                        localpool::POOL_ENTRY_TYPE_CONFLICT);
-    return localpool::POOL_ENTRY_TYPE_CONFLICT;
-  }
-  return returnvalue::OK;
-}
-
-#endif /* FSFW_DATAPOOLLOCAL_LOCALDATAPOOLMANAGER_H_ */
diff --git a/src/fsfw/datapoollocal/LocalDataSet.cpp b/src/fsfw/datapoollocal/LocalDataSet.cpp
deleted file mode 100644
index 2908ce51..00000000
--- a/src/fsfw/datapoollocal/LocalDataSet.cpp
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "fsfw/datapoollocal/LocalDataSet.h"
-
-#include <cmath>
-#include <cstring>
-
-#include "fsfw/datapoollocal/LocalDataPoolManager.h"
-#include "fsfw/serialize/SerializeAdapter.h"
-
-LocalDataSet::LocalDataSet(HasLocalDataPoolIF *hkOwner, uint32_t setId,
-                           const size_t maxNumberOfVariables)
-    : LocalPoolDataSetBase(hkOwner, setId, nullptr, maxNumberOfVariables),
-      poolVarList(maxNumberOfVariables) {
-  this->setContainer(poolVarList.data());
-}
-
-LocalDataSet::LocalDataSet(sid_t sid, const size_t maxNumberOfVariables)
-    : LocalPoolDataSetBase(sid, nullptr, maxNumberOfVariables), poolVarList(maxNumberOfVariables) {
-  this->setContainer(poolVarList.data());
-}
-
-LocalDataSet::~LocalDataSet() {}
diff --git a/src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp b/src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp
deleted file mode 100644
index 2108dde7..00000000
--- a/src/fsfw/datapoollocal/LocalPoolDataSetBase.cpp
+++ /dev/null
@@ -1,290 +0,0 @@
-#include <cmath>
-#include <cstring>
-
-#include "fsfw/datapoollocal.h"
-#include "fsfw/datapoollocal/LocalDataPoolManager.h"
-#include "fsfw/globalfunctions/bitutility.h"
-#include "fsfw/housekeeping/PeriodicHousekeepingHelper.h"
-#include "fsfw/objectmanager/ObjectManager.h"
-#include "fsfw/serialize/SerializeAdapter.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
-#include "internal/HasLocalDpIFUserAttorney.h"
-
-LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner, uint32_t setId,
-                                           PoolVariableIF **registeredVariablesArray,
-                                           const size_t maxNumberOfVariables, bool periodicHandling)
-    : PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-  if (hkOwner == nullptr) {
-    // Configuration error.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner " << "invalid!" << std::endl;
-#else
-    sif::printError(
-        "LocalPoolDataSetBase::LocalPoolDataSetBase: Owner "
-        "invalid!\n\r");
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-    return;
-  }
-  AccessPoolManagerIF *accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
-
-  if (accessor != nullptr) {
-    poolManager = accessor->getPoolManagerHandle();
-    mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
-  }
-
-  this->sid.objectId = hkOwner->getObjectId();
-  this->sid.ownerSetId = setId;
-
-  /* Data creators get a periodic helper for periodic HK data generation. */
-  if (periodicHandling) {
-    periodicHelper = new PeriodicHousekeepingHelper(this);
-  }
-}
-
-LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid, PoolVariableIF **registeredVariablesArray,
-                                           const size_t maxNumberOfVariables)
-    : PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-  HasLocalDataPoolIF *hkOwner = ObjectManager::instance()->get<HasLocalDataPoolIF>(sid.objectId);
-  if (hkOwner != nullptr) {
-    AccessPoolManagerIF *accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);
-    if (accessor != nullptr) {
-      mutexIfSingleDataCreator = accessor->getLocalPoolMutex();
-      poolManager = accessor->getPoolManagerHandle();
-    }
-  }
-
-  this->sid = sid;
-}
-
-LocalPoolDataSetBase::LocalPoolDataSetBase(PoolVariableIF **registeredVariablesArray,
-                                           const size_t maxNumberOfVariables,
-                                           bool protectEveryReadCommitCall)
-    : PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables) {
-  this->setReadCommitProtectionBehaviour(protectEveryReadCommitCall);
-}
-
-LocalPoolDataSetBase::~LocalPoolDataSetBase() {
-  /* We only delete objects which were created in the class constructor */
-  if (periodicHelper != nullptr) {
-    delete periodicHelper;
-  }
-  /* In case set was read but not comitted, we commit all variables with an invalid state */
-  if (state == States::STATE_SET_WAS_READ) {
-    for (uint16_t count = 0; count < fillCount; count++) {
-      if (registeredVariables[count] != nullptr) {
-        registeredVariables[count]->setValid(false);
-        registeredVariables[count]->commit(MutexIF::TimeoutType::WAITING, 20);
-      }
-    }
-  }
-}
-
-ReturnValue_t LocalPoolDataSetBase::lockDataPool(MutexIF::TimeoutType timeoutType,
-                                                 uint32_t timeoutMs) {
-  if (mutexIfSingleDataCreator != nullptr) {
-    return mutexIfSingleDataCreator->lockMutex(timeoutType, timeoutMs);
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalPoolDataSetBase::serializeWithValidityBuffer(
-    uint8_t **buffer, size_t *size, size_t maxSize,
-    SerializeIF::Endianness streamEndianness) const {
-  ReturnValue_t result = returnvalue::OK;
-  const uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount) / 8.0);
-  uint8_t *validityPtr = nullptr;
-#if defined(_MSC_VER) || defined(__clang__)
-  // Use a std::vector here because MSVC will (rightly) not create a fixed size array
-  // with a non constant size specifier. The Apple compiler (LLVM) will not accept
-  // the  initialization of a variable sized array
-  std::vector<uint8_t> validityMask(validityMaskSize, 0);
-  validityPtr = validityMask.data();
-#else
-  uint8_t validityMask[validityMaskSize] = {};
-  validityPtr = validityMask;
-#endif
-  uint8_t validBufferIndex = 0;
-  uint8_t validBufferIndexBit = 0;
-  for (uint16_t count = 0; count < fillCount; count++) {
-    if (registeredVariables[count]->isValid()) {
-      /* Set bit at correct position */
-      bitutil::set(validityPtr + validBufferIndex, validBufferIndexBit);
-    }
-    if (validBufferIndexBit == 7) {
-      validBufferIndex++;
-      validBufferIndexBit = 0;
-    } else {
-      validBufferIndexBit++;
-    }
-
-    result = registeredVariables[count]->serialize(buffer, size, maxSize, streamEndianness);
-    if (result != returnvalue::OK) {
-      return result;
-    }
-  }
-
-  if (*size + validityMaskSize > maxSize) {
-    return SerializeIF::BUFFER_TOO_SHORT;
-  }
-  // copy validity buffer to end
-  std::memcpy(*buffer, validityPtr, validityMaskSize);
-  *size += validityMaskSize;
-  return result;
-}
-
-ReturnValue_t LocalPoolDataSetBase::deSerializeWithValidityBuffer(
-    const uint8_t **buffer, size_t *size, SerializeIF::Endianness streamEndianness) {
-  ReturnValue_t result = returnvalue::FAILED;
-  for (uint16_t count = 0; count < fillCount; count++) {
-    result = registeredVariables[count]->deSerialize(buffer, size, streamEndianness);
-    if (result != returnvalue::OK) {
-      return result;
-    }
-  }
-
-  if (*size < std::ceil(static_cast<float>(fillCount) / 8.0)) {
-    return SerializeIF::STREAM_TOO_SHORT;
-  }
-
-  uint8_t validBufferIndex = 0;
-  uint8_t validBufferIndexBit = 0;
-  for (uint16_t count = 0; count < fillCount; count++) {
-    // set validity buffer here.
-    bool nextVarValid = false;
-    bitutil::get(*buffer + validBufferIndex, validBufferIndexBit, nextVarValid);
-    registeredVariables[count]->setValid(nextVarValid);
-
-    if (validBufferIndexBit == 7) {
-      validBufferIndex++;
-      validBufferIndexBit = 0;
-    } else {
-      validBufferIndexBit++;
-    }
-  }
-  return result;
-}
-
-ReturnValue_t LocalPoolDataSetBase::unlockDataPool() {
-  if (mutexIfSingleDataCreator != nullptr) {
-    return mutexIfSingleDataCreator->unlockMutex();
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalPoolDataSetBase::serializeLocalPoolIds(uint8_t **buffer, size_t *size,
-                                                          size_t maxSize,
-                                                          SerializeIF::Endianness streamEndianness,
-                                                          bool serializeFillCount) const {
-  /* Serialize fill count as uint8_t */
-  uint8_t fillCount = this->fillCount;
-  if (serializeFillCount) {
-    SerializeAdapter::serialize(&fillCount, buffer, size, maxSize, streamEndianness);
-  }
-  for (uint16_t count = 0; count < fillCount; count++) {
-    lp_id_t currentPoolId = registeredVariables[count]->getDataPoolId();
-    auto result =
-        SerializeAdapter::serialize(&currentPoolId, buffer, size, maxSize, streamEndianness);
-    if (result != returnvalue::OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::warning << "LocalPoolDataSetBase::serializeLocalPoolIds: " << "Serialization error!"
-                   << std::endl;
-#else
-      sif::printWarning(
-          "LocalPoolDataSetBase::serializeLocalPoolIds: "
-          "Serialization error!\n\r");
-#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
-      return result;
-    }
-  }
-  return returnvalue::OK;
-}
-
-uint8_t LocalPoolDataSetBase::getLocalPoolIdsSerializedSize(bool serializeFillCount) const {
-  if (serializeFillCount) {
-    return fillCount * sizeof(lp_id_t) + sizeof(uint8_t);
-  } else {
-    return fillCount * sizeof(lp_id_t);
-  }
-}
-
-size_t LocalPoolDataSetBase::getSerializedSize() const {
-  if (withValidityBuffer) {
-    uint8_t validityMaskSize = std::ceil(static_cast<float>(fillCount) / 8.0);
-    return validityMaskSize + PoolDataSetBase::getSerializedSize();
-  } else {
-    return PoolDataSetBase::getSerializedSize();
-  }
-}
-
-void LocalPoolDataSetBase::setValidityBufferGeneration(bool withValidityBuffer) {
-  this->withValidityBuffer = withValidityBuffer;
-}
-
-ReturnValue_t LocalPoolDataSetBase::deSerialize(const uint8_t **buffer, size_t *size,
-                                                SerializeIF::Endianness streamEndianness) {
-  if (withValidityBuffer) {
-    return this->deSerializeWithValidityBuffer(buffer, size, streamEndianness);
-  } else {
-    return PoolDataSetBase::deSerialize(buffer, size, streamEndianness);
-  }
-}
-
-ReturnValue_t LocalPoolDataSetBase::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
-                                              SerializeIF::Endianness streamEndianness) const {
-  if (withValidityBuffer) {
-    return this->serializeWithValidityBuffer(buffer, size, maxSize, streamEndianness);
-  } else {
-    return PoolDataSetBase::serialize(buffer, size, maxSize, streamEndianness);
-  }
-}
-
-void LocalPoolDataSetBase::setReportingEnabled(bool reportingEnabled) {
-  this->reportingEnabled = reportingEnabled;
-}
-
-bool LocalPoolDataSetBase::getReportingEnabled() const { return reportingEnabled; }
-
-void LocalPoolDataSetBase::initializePeriodicHelper(float collectionInterval,
-                                                    dur_millis_t minimumPeriodicInterval) {
-  periodicHelper->initialize(collectionInterval, minimumPeriodicInterval);
-}
-
-void LocalPoolDataSetBase::setChanged(bool changed) { this->changed = changed; }
-
-bool LocalPoolDataSetBase::hasChanged() const { return changed; }
-
-sid_t LocalPoolDataSetBase::getSid() const { return sid; }
-
-bool LocalPoolDataSetBase::isValid() const { return this->valid; }
-
-void LocalPoolDataSetBase::setValidity(bool valid, bool setEntriesRecursively) {
-  if (setEntriesRecursively) {
-    for (size_t idx = 0; idx < this->getFillCount(); idx++) {
-      registeredVariables[idx]->setValid(valid);
-    }
-  }
-  this->valid = valid;
-}
-
-object_id_t LocalPoolDataSetBase::getCreatorObjectId() {
-  if (poolManager != nullptr) {
-    return poolManager->getCreatorObjectId();
-  }
-  return objects::NO_OBJECT;
-}
-
-void LocalPoolDataSetBase::setAllVariablesReadOnly() {
-  for (size_t idx = 0; idx < this->getFillCount(); idx++) {
-    registeredVariables[idx]->setReadWriteMode(pool_rwm_t::VAR_READ);
-  }
-}
-
-float LocalPoolDataSetBase::getCollectionInterval() const {
-  if (periodicHelper != nullptr) {
-    return periodicHelper->getCollectionIntervalInSeconds();
-  } else {
-    return 0.0;
-  }
-}
-
-void LocalPoolDataSetBase::printSet() { return; }
diff --git a/src/fsfw/datapoollocal/LocalPoolObjectBase.h b/src/fsfw/datapoollocal/LocalPoolObjectBase.h
deleted file mode 100644
index a4ecbd55..00000000
--- a/src/fsfw/datapoollocal/LocalPoolObjectBase.h
+++ /dev/null
@@ -1,68 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
-#define FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_
-
-#include "MarkChangedIF.h"
-#include "fsfw/datapool/PoolVariableIF.h"
-#include "fsfw/objectmanager/SystemObjectIF.h"
-#include "fsfw/returnvalues/returnvalue.h"
-#include "localPoolDefinitions.h"
-
-class LocalDataPoolManager;
-class DataSetIF;
-class HasLocalDataPoolIF;
-
-/**
- * @brief 	This class serves as a non-template base for pool objects like pool variables
- * 			or pool vectors.
- */
-class LocalPoolObjectBase : public PoolVariableIF, public MarkChangedIF {
- public:
-  LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner, DataSetIF* dataSet,
-                      pool_rwm_t setReadWriteMode);
-
-  LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId, DataSetIF* dataSet = nullptr,
-                      pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
-
-  void setReadWriteMode(pool_rwm_t newReadWriteMode) override;
-  pool_rwm_t getReadWriteMode() const override;
-
-  bool isValid() const override;
-  void setValid(bool valid) override;
-
-  void setChanged(bool changed) override;
-  bool hasChanged() const override;
-
-  lp_id_t getDataPoolId() const override;
-  void setDataPoolId(lp_id_t poolId);
-
- protected:
-  /**
-   * @brief   To access the correct data pool entry on read and commit calls,
-   *          the data pool id is stored.
-   */
-  uint32_t localPoolId = PoolVariableIF::NO_PARAMETER;
-  /**
-   * @brief   The valid information as it was stored in the data pool
-   *          is copied to this attribute.
-   */
-  bool valid = false;
-
-  /**
-   * @brief   A local pool variable can be marked as changed.
-   */
-  bool changed = false;
-
-  /**
-   * @brief   The information whether the class is read-write or
-   *          read-only is stored here.
-   */
-  ReadWriteMode_t readWriteMode = pool_rwm_t::VAR_READ_WRITE;
-
-  //! @brief  Pointer to the class which manages the HK pool.
-  LocalDataPoolManager* hkManager = nullptr;
-
-  void reportReadCommitError(const char* variableType, ReturnValue_t error, bool read,
-                             object_id_t objectId, lp_id_t lpId);
-};
-
-#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLOBJECTBASE_H_ */
diff --git a/src/fsfw/datapoollocal/LocalPoolVariable.h b/src/fsfw/datapoollocal/LocalPoolVariable.h
deleted file mode 100644
index dc67095c..00000000
--- a/src/fsfw/datapoollocal/LocalPoolVariable.h
+++ /dev/null
@@ -1,197 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
-#define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
-
-#include "../datapool/DataSetIF.h"
-#include "../datapool/PoolVariableIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
-#include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterface.h"
-#include "AccessLocalPoolF.h"
-#include "HasLocalDataPoolIF.h"
-#include "LocalDataPoolManager.h"
-#include "LocalPoolObjectBase.h"
-#include "internal/LocalDpManagerAttorney.h"
-
-/**
- * @brief 	Local Pool Variable class which is used to access the local pools.
- * @details
- * This class is not stored in the map. Instead, it is used to access
- * the pool entries by using a pointer to the map storing the pool
- * entries. It can also be used to organize these pool entries into data sets.
- *
- * @tparam T The template parameter sets the type of the variable. Currently,
- * all plain data types are supported, but in principle  any type is possible.
- * @ingroup data_pool
- */
-template <typename T>
-class LocalPoolVariable : public LocalPoolObjectBase {
- public:
-  //! Default ctor is forbidden.
-  LocalPoolVariable() = delete;
-
-  /**
-   * This constructor is used by the data creators to have pool variable
-   * instances which can also be stored in datasets.
-   *
-   * It does not fetch the current value from the data pool, which
-   * has to be done by calling the read() operation.
-   * Datasets can be used to access multiple local pool entries in an
-   * efficient way. A pointer to a dataset can be passed to register
-   * the pool variable in that dataset directly.
-   * @param poolId ID of the local pool entry.
-   * @param hkOwner Pointer of the owner. This will generally be the calling
-   * class itself which passes "this".
-   * @param dataSet The data set in which the variable shall register itself.
-   * If nullptr, the variable is not registered.
-   * @param setReadWriteMode Specify the read-write mode of the pool variable.
-   */
-  LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId, DataSetIF* dataSet = nullptr,
-                    pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
-
-  /**
-   * This constructor is used by data users like controllers to have
-   * access to the local pool variables of data creators by supplying
-   * the respective creator object ID.
-   *
-   * It does not fetch the current value from the data pool, which
-   * has to be done by calling the read() operation.
-   * Datasets can be used to access multiple local pool entries in an
-   * efficient way. A pointer to a dataset can be passed to register
-   * the pool variable in that dataset directly.
-   * @param poolId ID of the local pool entry.
-   * @param hkOwner object ID of the pool owner.
-   * @param dataSet The data set in which the variable shall register itself.
-   * If nullptr, the variable is not registered.
-   * @param setReadWriteMode Specify the read-write mode of the pool variable.
-   *
-   */
-  LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId, DataSetIF* dataSet = nullptr,
-                    pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
-  /**
-   * Variation which takes the global unique identifier of a pool variable.
-   * @param globalPoolId
-   * @param dataSet
-   * @param setReadWriteMode
-   */
-  LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet = nullptr,
-                    pool_rwm_t setReadWriteMode = pool_rwm_t::VAR_READ_WRITE);
-
-  virtual ~LocalPoolVariable() {};
-
-  /**
-   * @brief	This is the local copy of the data pool entry.
-   * @details	The user can work on this attribute
-   * 			just like he would on a simple local variable.
-   */
-  T value = 0;
-
-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          SerializeIF::Endianness streamEndianness) const override;
-  size_t getSerializedSize() const override;
-  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                            SerializeIF::Endianness streamEndianness) override;
-
-  /**
-   * @brief	This is a call to read the array's values
-   * 			from the global data pool.
-   * @details
-   * When executed, this operation tries to fetch the pool entry with matching
-   * data pool id from the data pool and copies all array values and the valid
-   * information to its local attributes.
-   * In case of a failure (wrong type, size or pool id not found), the
-   * variable is set to zero and invalid.
-   * The read call is protected with a lock.
-   * It is recommended to use DataSets to read and commit multiple variables
-   * at once to avoid the overhead of unnecessary lock und unlock operations.
-   *
-   */
-  ReturnValue_t read(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                     uint32_t timeoutMs = 20) override;
-  /**
-   * @brief	The commit call copies the array values back to the data pool.
-   * @details
-   * It checks type and size, as well as if the variable is writable. If so,
-   * the value is copied and the local valid flag is written back as well.
-   * The read call is protected with a lock.
-   * It is recommended to use DataSets to read and commit multiple variables
-   * at once to avoid the overhead of unnecessary lock und unlock operations.
-   */
-  ReturnValue_t commit(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                       uint32_t timeoutMs = 20) override;
-
-  /**
-   * @brief	This commit function can be used to set the pool variable valid
-   * 			as well.
-   * @param setValid
-   * @param timeoutType
-   * @param timeoutMs
-   * @return
-   */
-  ReturnValue_t commit(bool setValid,
-                       MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                       uint32_t timeoutMs = 20);
-
-  LocalPoolVariable<T>& operator=(const T& newValue);
-  LocalPoolVariable<T>& operator=(const LocalPoolVariable<T>& newPoolVariable);
-
-  //! Explicit type conversion operator. Allows casting the class to
-  //! its template type to perform operations on value.
-  explicit operator T() const;
-
-  bool operator==(const LocalPoolVariable<T>& other) const;
-  bool operator==(const T& other) const;
-
-  bool operator!=(const LocalPoolVariable<T>& other) const;
-  bool operator!=(const T& other) const;
-
-  bool operator<(const LocalPoolVariable<T>& other) const;
-  bool operator<(const T& other) const;
-
-  bool operator>(const LocalPoolVariable<T>& other) const;
-  bool operator>(const T& other) const;
-
- protected:
-  /**
-   * @brief	Like #read, but without a lock protection of the global pool.
-   * @details
-   * The operation does NOT provide any mutual exclusive protection by itself.
-   * This can be used if the lock is handled externally to avoid the overhead
-   * of consecutive lock und unlock operations.
-   * Declared protected to discourage free public usage.
-   */
-  ReturnValue_t readWithoutLock() override;
-  /**
-   * @brief	Like #commit, but without a lock protection of the global pool.
-   * @details
-   * The operation does NOT provide any mutual exclusive protection by itself.
-   * This can be used if the lock is handled externally to avoid the overhead
-   * of consecutive lock und unlock operations.
-   * Declared protected to discourage free public usage.
-   */
-  ReturnValue_t commitWithoutLock() override;
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  // std::ostream is the type for object std::cout
-  template <typename U>
-  friend std::ostream& operator<<(std::ostream& out, const LocalPoolVariable<U>& var);
-#endif
-};
-
-#include "LocalPoolVariable.tpp"
-
-template <class T>
-using lp_var_t = LocalPoolVariable<T>;
-
-using lp_bool_t = LocalPoolVariable<uint8_t>;
-using lp_uint8_t = LocalPoolVariable<uint8_t>;
-using lp_uint16_t = LocalPoolVariable<uint16_t>;
-using lp_uint32_t = LocalPoolVariable<uint32_t>;
-using lp_uint64_t = LocalPoolVariable<uint64_t>;
-using lp_int8_t = LocalPoolVariable<int8_t>;
-using lp_int16_t = LocalPoolVariable<int16_t>;
-using lp_int32_t = LocalPoolVariable<int32_t>;
-using lp_int64_t = LocalPoolVariable<int64_t>;
-using lp_float_t = LocalPoolVariable<float>;
-using lp_double_t = LocalPoolVariable<double>;
-
-#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_ */
diff --git a/src/fsfw/datapoollocal/LocalPoolVariable.tpp b/src/fsfw/datapoollocal/LocalPoolVariable.tpp
deleted file mode 100644
index 969a047b..00000000
--- a/src/fsfw/datapoollocal/LocalPoolVariable.tpp
+++ /dev/null
@@ -1,193 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
-#define FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_
-
-#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_H_
-#error Include LocalPoolVariable.h before LocalPoolVariable.tpp!
-#endif
-
-template <typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
-                                               DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
-    : LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
-
-template <typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(object_id_t poolOwner, lp_id_t poolId,
-                                               DataSetIF* dataSet, pool_rwm_t setReadWriteMode)
-    : LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
-
-template <typename T>
-inline LocalPoolVariable<T>::LocalPoolVariable(gp_id_t globalPoolId, DataSetIF* dataSet,
-                                               pool_rwm_t setReadWriteMode)
-    : LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet,
-                          setReadWriteMode) {}
-
-template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::read(MutexIF::TimeoutType timeoutType,
-                                                uint32_t timeoutMs) {
-  if (hkManager == nullptr) {
-    return readWithoutLock();
-  }
-  MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
-  ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = readWithoutLock();
-  mutex->unlockMutex();
-  return result;
-}
-
-template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::readWithoutLock() {
-  if (readWriteMode == pool_rwm_t::VAR_WRITE) {
-    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, true,
-                          targetObjectId, localPoolId);
-    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-  }
-
-  PoolEntry<T>* poolEntry = nullptr;
-  ReturnValue_t result =
-      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-  if (result != returnvalue::OK) {
-    object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
-    return result;
-  }
-
-  this->value = *(poolEntry->getDataPtr());
-  this->valid = poolEntry->getValid();
-  return returnvalue::OK;
-}
-
-template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commit(bool setValid, MutexIF::TimeoutType timeoutType,
-                                                  uint32_t timeoutMs) {
-  this->setValid(setValid);
-  return commit(timeoutType, timeoutMs);
-}
-
-template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commit(MutexIF::TimeoutType timeoutType,
-                                                  uint32_t timeoutMs) {
-  if (hkManager == nullptr) {
-    return commitWithoutLock();
-  }
-  MutexIF* mutex = LocalDpManagerAttorney::getMutexHandle(*hkManager);
-  ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  result = commitWithoutLock();
-  mutex->unlockMutex();
-  return result;
-}
-
-template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::commitWithoutLock() {
-  if (readWriteMode == pool_rwm_t::VAR_READ) {
-    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, false,
-                          targetObjectId, localPoolId);
-    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-  }
-
-  PoolEntry<T>* poolEntry = nullptr;
-  ReturnValue_t result =
-      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-  if (result != returnvalue::OK) {
-    object_id_t ownerObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVariable", result, false, ownerObjectId, localPoolId);
-    return result;
-  }
-
-  *(poolEntry->getDataPtr()) = this->value;
-  poolEntry->setValid(this->valid);
-  return returnvalue::OK;
-}
-
-template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::serialize(
-    uint8_t** buffer, size_t* size, const size_t max_size,
-    SerializeIF::Endianness streamEndianness) const {
-  return SerializeAdapter::serialize(&value, buffer, size, max_size, streamEndianness);
-}
-
-template <typename T>
-inline size_t LocalPoolVariable<T>::getSerializedSize() const {
-  return SerializeAdapter::getSerializedSize(&value);
-}
-
-template <typename T>
-inline ReturnValue_t LocalPoolVariable<T>::deSerialize(const uint8_t** buffer, size_t* size,
-                                                       SerializeIF::Endianness streamEndianness) {
-  return SerializeAdapter::deSerialize(&value, buffer, size, streamEndianness);
-}
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-template <typename T>
-inline std::ostream& operator<<(std::ostream& out, const LocalPoolVariable<T>& var) {
-  out << var.value;
-  return out;
-}
-#endif
-
-template <typename T>
-inline LocalPoolVariable<T>::operator T() const {
-  return value;
-}
-
-template <typename T>
-inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator=(const T& newValue) {
-  value = newValue;
-  return *this;
-}
-
-template <typename T>
-inline LocalPoolVariable<T>& LocalPoolVariable<T>::operator=(
-    const LocalPoolVariable<T>& newPoolVariable) {
-  value = newPoolVariable.value;
-  return *this;
-}
-
-template <typename T>
-inline bool LocalPoolVariable<T>::operator==(const LocalPoolVariable<T>& other) const {
-  return this->value == other.value;
-}
-
-template <typename T>
-inline bool LocalPoolVariable<T>::operator==(const T& other) const {
-  return this->value == other;
-}
-
-template <typename T>
-inline bool LocalPoolVariable<T>::operator!=(const LocalPoolVariable<T>& other) const {
-  return not(*this == other);
-}
-
-template <typename T>
-inline bool LocalPoolVariable<T>::operator!=(const T& other) const {
-  return not(*this == other);
-}
-
-template <typename T>
-inline bool LocalPoolVariable<T>::operator<(const LocalPoolVariable<T>& other) const {
-  return this->value < other.value;
-}
-
-template <typename T>
-inline bool LocalPoolVariable<T>::operator<(const T& other) const {
-  return this->value < other;
-}
-
-template <typename T>
-inline bool LocalPoolVariable<T>::operator>(const LocalPoolVariable<T>& other) const {
-  return not(*this < other);
-}
-
-template <typename T>
-inline bool LocalPoolVariable<T>::operator>(const T& other) const {
-  return not(*this < other);
-}
-
-#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVARIABLE_TPP_ */
diff --git a/src/fsfw/datapoollocal/LocalPoolVector.tpp b/src/fsfw/datapoollocal/LocalPoolVector.tpp
deleted file mode 100644
index 939405a9..00000000
--- a/src/fsfw/datapoollocal/LocalPoolVector.tpp
+++ /dev/null
@@ -1,177 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
-#define FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_
-
-#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_H_
-#error Include LocalPoolVector.h before LocalPoolVector.tpp!
-#endif
-
-template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(HasLocalDataPoolIF* hkOwner, lp_id_t poolId,
-                                                       DataSetIF* dataSet,
-                                                       pool_rwm_t setReadWriteMode)
-    : LocalPoolObjectBase(poolId, hkOwner, dataSet, setReadWriteMode) {}
-
-template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(object_id_t poolOwner, lp_id_t poolId,
-                                                       DataSetIF* dataSet,
-                                                       pool_rwm_t setReadWriteMode)
-    : LocalPoolObjectBase(poolOwner, poolId, dataSet, setReadWriteMode) {}
-
-template <typename T, uint16_t vectorSize>
-inline LocalPoolVector<T, vectorSize>::LocalPoolVector(gp_id_t globalPoolId, DataSetIF* dataSet,
-                                                       pool_rwm_t setReadWriteMode)
-    : LocalPoolObjectBase(globalPoolId.objectId, globalPoolId.localPoolId, dataSet,
-                          setReadWriteMode) {}
-
-template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::read(MutexIF::TimeoutType timeoutType,
-                                                          uint32_t timeoutMs) {
-  MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-  return readWithoutLock();
-}
-template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::readWithoutLock() {
-  if (readWriteMode == pool_rwm_t::VAR_WRITE) {
-    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, true,
-                          targetObjectId, localPoolId);
-    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-  }
-
-  PoolEntry<T>* poolEntry = nullptr;
-  ReturnValue_t result =
-      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-  memset(this->value, 0, vectorSize * sizeof(T));
-
-  if (result != returnvalue::OK) {
-    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", result, true, targetObjectId, localPoolId);
-    return result;
-  }
-  std::memcpy(this->value, poolEntry->getDataPtr(), poolEntry->getByteSize());
-  this->valid = poolEntry->getValid();
-  return returnvalue::OK;
-}
-
-template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(bool valid,
-                                                            MutexIF::TimeoutType timeoutType,
-                                                            uint32_t timeoutMs) {
-  this->setValid(valid);
-  return commit(timeoutType, timeoutMs);
-}
-
-template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::commit(MutexIF::TimeoutType timeoutType,
-                                                            uint32_t timeoutMs) {
-  MutexGuard(LocalDpManagerAttorney::getMutexHandle(*hkManager), timeoutType, timeoutMs);
-  return commitWithoutLock();
-}
-
-template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::commitWithoutLock() {
-  if (readWriteMode == pool_rwm_t::VAR_READ) {
-    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", PoolVariableIF::INVALID_READ_WRITE_MODE, false,
-                          targetObjectId, localPoolId);
-    return PoolVariableIF::INVALID_READ_WRITE_MODE;
-  }
-  PoolEntry<T>* poolEntry = nullptr;
-  ReturnValue_t result =
-      LocalDpManagerAttorney::fetchPoolEntry(*hkManager, localPoolId, &poolEntry);
-  if (result != returnvalue::OK) {
-    object_id_t targetObjectId = hkManager->getCreatorObjectId();
-    reportReadCommitError("LocalPoolVector", result, false, targetObjectId, localPoolId);
-    return result;
-  }
-  std::memcpy(poolEntry->getDataPtr(), this->value, poolEntry->getByteSize());
-  poolEntry->setValid(this->valid);
-  return returnvalue::OK;
-}
-
-template <typename T, uint16_t vectorSize>
-inline T& LocalPoolVector<T, vectorSize>::operator[](size_t i) {
-  if (i < vectorSize) {
-    return value[i];
-  }
-  // If this happens, I have to set some value. I consider this
-  // a configuration error, but I wont exit here.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-                  " last value!"
-               << std::endl;
-#else
-  sif::printWarning(
-      "LocalPoolVector: Invalid index. Setting or returning"
-      " last value!\n");
-#endif
-  return value[vectorSize - 1];
-}
-
-template <typename T, uint16_t vectorSize>
-inline const T& LocalPoolVector<T, vectorSize>::operator[](size_t i) const {
-  if (i < vectorSize) {
-    return value[i];
-  }
-  // If this happens, I have to set some value. I consider this
-  // a configuration error, but I wont exit here.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-  sif::warning << "LocalPoolVector: Invalid index. Setting or returning"
-                  " last value!"
-               << std::endl;
-#else
-  sif::printWarning(
-      "LocalPoolVector: Invalid index. Setting or returning"
-      " last value!\n");
-#endif
-  return value[vectorSize - 1];
-}
-
-template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::serialize(
-    uint8_t** buffer, size_t* size, size_t maxSize,
-    SerializeIF::Endianness streamEndianness) const {
-  ReturnValue_t result = returnvalue::FAILED;
-  for (uint16_t i = 0; i < vectorSize; i++) {
-    result = SerializeAdapter::serialize(&(value[i]), buffer, size, maxSize, streamEndianness);
-    if (result != returnvalue::OK) {
-      break;
-    }
-  }
-  return result;
-}
-
-template <typename T, uint16_t vectorSize>
-inline size_t LocalPoolVector<T, vectorSize>::getSerializedSize() const {
-  return vectorSize * SerializeAdapter::getSerializedSize(value);
-}
-
-template <typename T, uint16_t vectorSize>
-inline ReturnValue_t LocalPoolVector<T, vectorSize>::deSerialize(
-    const uint8_t** buffer, size_t* size, SerializeIF::Endianness streamEndianness) {
-  ReturnValue_t result = returnvalue::FAILED;
-  for (uint16_t i = 0; i < vectorSize; i++) {
-    result = SerializeAdapter::deSerialize(&(value[i]), buffer, size, streamEndianness);
-    if (result != returnvalue::OK) {
-      break;
-    }
-  }
-  return result;
-}
-
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-template <typename T, uint16_t vectorSize>
-inline std::ostream& operator<<(std::ostream& out, const LocalPoolVector<T, vectorSize>& var) {
-  out << "Vector: [";
-  for (int i = 0; i < vectorSize; i++) {
-    out << var.value[i];
-    if (i < vectorSize - 1) {
-      out << ", ";
-    }
-  }
-  out << "]";
-  return out;
-}
-#endif
-
-#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLVECTOR_TPP_ */
diff --git a/src/fsfw/datapoollocal/ProvidesDataPoolSubscriptionIF.h b/src/fsfw/datapoollocal/ProvidesDataPoolSubscriptionIF.h
deleted file mode 100644
index ba3f7a43..00000000
--- a/src/fsfw/datapoollocal/ProvidesDataPoolSubscriptionIF.h
+++ /dev/null
@@ -1,152 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
-#define FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_
-
-#include "fsfw/housekeeping/AcceptsHkPacketsIF.h"
-#include "fsfw/ipc/MessageQueueIF.h"
-#include "fsfw/ipc/messageQueueDefinitions.h"
-#include "fsfw/returnvalues/returnvalue.h"
-#include "localPoolDefinitions.h"
-
-namespace subdp {
-
-struct ParamsBase {
-  ParamsBase(sid_t sid, bool enableReporting, float collectionInterval, bool diagnostics)
-      : sid(sid),
-        enableReporting(enableReporting),
-        collectionInterval(collectionInterval),
-        diagnostics(diagnostics) {}
-
-  [[nodiscard]] bool isDiagnostics() const { return diagnostics; }
-
-  sid_t sid;
-  bool enableReporting;
-  float collectionInterval;
-  MessageQueueId_t receiver = MessageQueueIF::NO_QUEUE;
-
- protected:
-  bool diagnostics;
-};
-
-struct RegularHkPeriodicParams : public ParamsBase {
-  RegularHkPeriodicParams(sid_t sid, bool enableReporting, float collectionInterval)
-      : ParamsBase(sid, enableReporting, collectionInterval, false) {}
-};
-
-struct DiagnosticsHkPeriodicParams : public ParamsBase {
-  DiagnosticsHkPeriodicParams(sid_t sid, bool enableReporting, float collectionInterval)
-      : ParamsBase(sid, enableReporting, collectionInterval, true) {}
-};
-
-struct RegularHkUpdateParams : public ParamsBase {
-  RegularHkUpdateParams(sid_t sid, bool enableReporting)
-      : ParamsBase(sid, enableReporting, 0.0, false) {}
-};
-
-struct DiagnosticsHkUpdateParams : public ParamsBase {
-  DiagnosticsHkUpdateParams(sid_t sid, bool enableReporting)
-      : ParamsBase(sid, enableReporting, 0.0, true) {}
-};
-}  // namespace subdp
-
-class ProvidesDataPoolSubscriptionIF {
- public:
-  virtual ~ProvidesDataPoolSubscriptionIF() = default;
-  /**
-   * @brief   Subscribe for the generation of periodic packets. Used for regular HK packets
-   * @details
-   * This subscription mechanism will generally be used by the data creator
-   * to generate housekeeping packets which are downlinked directly.
-   * @return
-   */
-  virtual ReturnValue_t subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams params) = 0;
-  /**
-   * @brief   Subscribe for the generation of periodic packets. Used for diagnostic packets
-   * @details
-   * This subscription mechanism will generally be used by the data creator
-   * to generate housekeeping packets which are downlinked directly.
-   * @return
-   */
-  virtual ReturnValue_t subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams params) = 0;
-
-  [[deprecated(
-      "Please use the new API which takes all arguments as one wrapper "
-      "struct")]] virtual ReturnValue_t
-  subscribeForPeriodicPacket(sid_t sid, bool enableReporting, float collectionInterval,
-                             bool isDiagnostics,
-                             object_id_t packetDestination = objects::NO_OBJECT) {
-    if (isDiagnostics) {
-      subdp::DiagnosticsHkPeriodicParams params(sid, enableReporting, collectionInterval);
-      return subscribeForDiagPeriodicPacket(params);
-    } else {
-      subdp::RegularHkPeriodicParams params(sid, enableReporting, collectionInterval);
-      return subscribeForRegularPeriodicPacket(params);
-    }
-  }
-
-  /**
-   * @brief   Subscribe for the  generation of packets if the dataset
-   *          is marked as changed.
-   * @details
-   * This subscription mechanism will generally be used by the data creator.
-   * @param sid
-   * @param isDiagnostics
-   * @param packetDestination
-   * @return
-   */
-  virtual ReturnValue_t subscribeForRegularUpdatePacket(subdp::RegularHkUpdateParams params) = 0;
-  virtual ReturnValue_t subscribeForDiagUpdatePacket(subdp::DiagnosticsHkUpdateParams params) = 0;
-
-  [[deprecated(
-      "Please use the new API which takes all arguments as one wrapper "
-      "struct")]] virtual ReturnValue_t
-  subscribeForUpdatePacket(sid_t sid, bool reportingEnabled, bool isDiagnostics,
-                           object_id_t packetDestination = objects::NO_OBJECT) {
-    if (isDiagnostics) {
-      subdp::DiagnosticsHkUpdateParams params(sid, reportingEnabled);
-      return subscribeForDiagUpdatePacket(params);
-    } else {
-      subdp::RegularHkUpdateParams params(sid, reportingEnabled);
-      return subscribeForRegularUpdatePacket(params);
-    }
-  }
-
-  /**
-   * @brief   Subscribe for a notification message which will be sent
-   *          if a dataset has changed.
-   * @details
-   * This subscription mechanism will generally be used internally by
-   * other software components.
-   * @param setId                 Set ID of the set to receive update messages from.
-   * @param destinationObject     Object ID of the receiver.
-   * @param targetQueueId         Receiver queue ID
-   * @param generateSnapshot      If this is set to true, a copy of the current data with a
-   *                              timestamp will be generated and sent via message.
-   *                              Otherwise, only an notification message is sent.
-   * @return
-   */
-  virtual ReturnValue_t subscribeForSetUpdateMessage(uint32_t setId, object_id_t destinationObject,
-                                                     MessageQueueId_t targetQueueId,
-                                                     bool generateSnapshot) = 0;
-  /**
-   * @brief   Subscribe for an notification message which will be sent if a
-   *          pool variable has changed.
-   * @details
-   * This subscription mechanism will generally be used internally by
-   * other software components.
-   * @param localPoolId           Pool ID of the pool variable
-   * @param destinationObject     Object ID of the receiver
-   * @param targetQueueId         Receiver queue ID
-   * @param generateSnapshot      If this is set to true, a copy of the current data with a
-   *                              timestamp will be generated and sent via message. Otherwise,
-   *                              only an notification message is sent.
-   * @return
-   */
-  virtual ReturnValue_t subscribeForVariableUpdateMessage(lp_id_t localPoolId,
-                                                          object_id_t destinationObject,
-                                                          MessageQueueId_t targetQueueId,
-                                                          bool generateSnapshot) = 0;
-};
-
-#endif /* FSFW_DATAPOOLLOCAL_PROVIDESDATAPOOLSUBSCRIPTION_H_ */
diff --git a/src/fsfw/datapoollocal/SharedLocalDataSet.h b/src/fsfw/datapoollocal/SharedLocalDataSet.h
deleted file mode 100644
index e65bad19..00000000
--- a/src/fsfw/datapoollocal/SharedLocalDataSet.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
-#define FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_
-
-#include <vector>
-
-#include "../datapool/SharedDataSetIF.h"
-#include "../objectmanager/SystemObject.h"
-#include "LocalPoolDataSetBase.h"
-
-/**
- * This local dataset variation can be used if the dataset is used concurrently across
- * multiple threads. It provides a lock in addition to all other functionalities provided
- * by the LocalPoolDataSetBase class.
- *
- * The user is completely responsible for lockingand unlocking the dataset when using the
- * shared dataset.
- */
-class SharedLocalDataSet : public SystemObject,
-                           public LocalPoolDataSetBase,
-                           public SharedDataSetIF {
- public:
-  SharedLocalDataSet(object_id_t objectId, HasLocalDataPoolIF* owner, uint32_t setId,
-                     const size_t maxSize);
-  SharedLocalDataSet(object_id_t objectId, sid_t sid, const size_t maxSize);
-
-  virtual ~SharedLocalDataSet();
-
-  ReturnValue_t lockDataset(MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING,
-                            dur_millis_t mutexTimeout = 20) override;
-  ReturnValue_t unlockDataset() override;
-
- private:
-  MutexIF* datasetLock = nullptr;
-  std::vector<PoolVariableIF*> poolVarVector;
-};
-
-#endif /* FSFW_DATAPOOLLOCAL_SHAREDLOCALDATASET_H_ */
diff --git a/src/fsfw/datapoollocal/internal/CMakeLists.txt b/src/fsfw/datapoollocal/internal/CMakeLists.txt
deleted file mode 100644
index 6585d06e..00000000
--- a/src/fsfw/datapoollocal/internal/CMakeLists.txt
+++ /dev/null
@@ -1,2 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE HasLocalDpIFUserAttorney.cpp
-                                        HasLocalDpIFManagerAttorney.cpp)
diff --git a/src/fsfw/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp b/src/fsfw/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
deleted file mode 100644
index 14fd9bbc..00000000
--- a/src/fsfw/datapoollocal/internal/HasLocalDpIFManagerAttorney.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-#include "HasLocalDpIFManagerAttorney.h"
-
-#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
-#include "fsfw/datapoollocal/LocalPoolDataSetBase.h"
-#include "fsfw/datapoollocal/LocalPoolObjectBase.h"
-
-LocalPoolDataSetBase* HasLocalDpIFManagerAttorney::getDataSetHandle(HasLocalDataPoolIF* clientIF,
-                                                                    sid_t sid) {
-  return clientIF->getDataSetHandle(sid);
-}
-
-LocalPoolObjectBase* HasLocalDpIFManagerAttorney::getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
-                                                                      lp_id_t localPoolId) {
-  return clientIF->getPoolObjectHandle(localPoolId);
-}
-
-object_id_t HasLocalDpIFManagerAttorney::getObjectId(HasLocalDataPoolIF* clientIF) {
-  return clientIF->getObjectId();
-}
diff --git a/src/fsfw/datapoollocal/internal/HasLocalDpIFManagerAttorney.h b/src/fsfw/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
deleted file mode 100644
index f8547e10..00000000
--- a/src/fsfw/datapoollocal/internal/HasLocalDpIFManagerAttorney.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
-#define FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_
-
-#include "fsfw/datapoollocal/localPoolDefinitions.h"
-
-class HasLocalDataPoolIF;
-class LocalPoolDataSetBase;
-class LocalPoolObjectBase;
-
-class HasLocalDpIFManagerAttorney {
-  static LocalPoolDataSetBase* getDataSetHandle(HasLocalDataPoolIF* clientIF, sid_t sid);
-
-  static LocalPoolObjectBase* getPoolObjectHandle(HasLocalDataPoolIF* clientIF,
-                                                  lp_id_t localPoolId);
-
-  static object_id_t getObjectId(HasLocalDataPoolIF* clientIF);
-
-  friend class LocalDataPoolManager;
-};
-
-#endif /* FSFW_DATAPOOLLOCAL_HASLOCALDPIFMANAGERATTORNEY_H_ */
diff --git a/src/fsfw/datapoollocal/internal/HasLocalDpIFUserAttorney.cpp b/src/fsfw/datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
deleted file mode 100644
index baa2d9a1..00000000
--- a/src/fsfw/datapoollocal/internal/HasLocalDpIFUserAttorney.cpp
+++ /dev/null
@@ -1,8 +0,0 @@
-#include "HasLocalDpIFUserAttorney.h"
-
-#include "fsfw/datapoollocal/AccessLocalPoolF.h"
-#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
-
-AccessPoolManagerIF* HasLocalDpIFUserAttorney::getAccessorHandle(HasLocalDataPoolIF* clientIF) {
-  return clientIF->getAccessorHandle();
-}
diff --git a/src/fsfw/datapoollocal/internal/LocalPoolDataSetAttorney.h b/src/fsfw/datapoollocal/internal/LocalPoolDataSetAttorney.h
deleted file mode 100644
index 2cd75774..00000000
--- a/src/fsfw/datapoollocal/internal/LocalPoolDataSetAttorney.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
-#define FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_
-
-#include "fsfw/datapoollocal/LocalPoolDataSetBase.h"
-
-class LocalPoolDataSetAttorney {
- private:
-  static void initializePeriodicHelper(LocalPoolDataSetBase& set, float collectionInterval,
-                                       uint32_t minimumPeriodicIntervalMs) {
-    set.initializePeriodicHelper(collectionInterval, minimumPeriodicIntervalMs);
-  }
-
-  static void setReportingEnabled(LocalPoolDataSetBase& set, bool enabled) {
-    set.setReportingEnabled(enabled);
-  }
-
-  static bool getReportingEnabled(LocalPoolDataSetBase& set) { return set.getReportingEnabled(); }
-
-  static PeriodicHousekeepingHelper* getPeriodicHelper(LocalPoolDataSetBase& set) {
-    return set.periodicHelper;
-  }
-
-  friend class LocalDataPoolManager;
-};
-
-#endif /* FSFW_DATAPOOLLOCAL_LOCALPOOLDATASETATTORNEY_H_ */
diff --git a/src/fsfw/devicehandlers/DeviceHandlerBase.cpp b/src/fsfw/devicehandlers/DeviceHandlerBase.cpp
index 00d6c451..44ae9fee 100644
--- a/src/fsfw/devicehandlers/DeviceHandlerBase.cpp
+++ b/src/fsfw/devicehandlers/DeviceHandlerBase.cpp
@@ -1,11 +1,10 @@
 #include "DeviceHandlerBase.h"
 
 #include "fsfw/datapool/PoolReadGuard.h"
-#include "fsfw/datapoollocal/LocalPoolVariable.h"
+#include "fsfw/datapool/PoolVariable.h"
 #include "fsfw/devicehandlers/AcceptsDeviceResponsesIF.h"
 #include "fsfw/devicehandlers/DeviceTmReportingWrapper.h"
 #include "fsfw/globalfunctions/CRC.h"
-#include "fsfw/housekeeping/HousekeepingMessage.h"
 #include "fsfw/ipc/MessageQueueMessage.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
@@ -28,11 +27,12 @@ DeviceHandlerBase::DeviceHandlerBase(object_id_t setObjectId, object_id_t device
       storedRawData(StorageManagerIF::INVALID_ADDRESS),
       deviceCommunicationId(deviceCommunication),
       comCookie(comCookie),
+      sharedPool(DeviceHandlerBase::getObjectId()),
       healthHelper(this, setObjectId),
       modeHelper(this),
       parameterHelper(this),
       actionHelper(this, nullptr),
-      poolManager(this, nullptr),
+      hkHelper(this, nullptr),
       childTransitionFailure(returnvalue::OK),
       fdirInstance(fdirInstance),
       defaultFDIRUsed(fdirInstance == nullptr),
@@ -111,7 +111,7 @@ ReturnValue_t DeviceHandlerBase::performOperation(uint8_t counter) {
       doGetRead();
       /* This will be performed after datasets have been updated by the
       custom device implementation. */
-      poolManager.performHkOperation();
+      hkHelper.performHkOperation();
       break;
     default:
       break;
@@ -152,8 +152,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
   }
 
   if (rawDataReceiverId != objects::NO_OBJECT) {
-    AcceptsDeviceResponsesIF* rawReceiver =
-        ObjectManager::instance()->get<AcceptsDeviceResponsesIF>(rawDataReceiverId);
+    auto* rawReceiver = ObjectManager::instance()->get<AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
     if (rawReceiver == nullptr) {
       printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
@@ -214,7 +213,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
     return result;
   }
 
-  result = poolManager.initialize(commandQueue);
+  result = hkHelper.initialize(commandQueue);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -226,7 +225,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
     // Set temperature target state to NON_OP.
     if (pg.getReadResult() == returnvalue::OK) {
       thermalSet->heaterRequest.value = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
-      thermalSet->heaterRequest.setValid(true);
+      // thermalSet->heaterRequest.setValid(true);
     }
   }
 
@@ -288,7 +287,7 @@ void DeviceHandlerBase::readCommandQueue() {
     return;
   }
 
-  result = poolManager.handleHousekeepingMessage(&command);
+  result = hkHelper.handleHousekeepingMessage(&command);
   if (result == returnvalue::OK) {
     return;
   }
@@ -413,7 +412,7 @@ ReturnValue_t DeviceHandlerBase::isModeCombinationValid(Mode_t mode, Submode_t s
 }
 
 ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
-    DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles, LocalPoolDataSetBase* replyDataSet,
+    DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles, dp::SharedSetBase* replyDataSet,
     size_t replyLen, bool periodic, bool hasDifferentReplyId, DeviceCommandId_t replyId,
     Countdown* countdown) {
   // No need to check, as we may try to insert multiple times.
@@ -428,7 +427,7 @@ ReturnValue_t DeviceHandlerBase::insertInCommandAndReplyMap(
 
 ReturnValue_t DeviceHandlerBase::insertInReplyMap(DeviceCommandId_t replyId,
                                                   uint16_t maxDelayCycles,
-                                                  LocalPoolDataSetBase* dataSet, size_t replyLen,
+                                                  dp::SharedSetBase* dataSet, size_t replyLen,
                                                   bool periodic, Countdown* countdown) {
   DeviceReplyInfo info;
   info.maxDelayCycles = maxDelayCycles;
@@ -529,7 +528,7 @@ ReturnValue_t DeviceHandlerBase::updatePeriodicReply(bool enable, DeviceCommandI
 }
 
 ReturnValue_t DeviceHandlerBase::setReplyDataset(DeviceCommandId_t replyId,
-                                                 LocalPoolDataSetBase* dataSet) {
+                                                 dp::SharedSetBase* dataSet) {
   auto replyIter = deviceReplyMap.find(replyId);
   if (replyIter == deviceReplyMap.end()) {
     return returnvalue::FAILED;
@@ -593,7 +592,7 @@ void DeviceHandlerBase::setMode(Mode_t newMode, uint8_t newSubmode) {
       if (thermalSet->heaterRequest.value != ThermalComponentIF::STATE_REQUEST_IGNORE) {
         thermalSet->heaterRequest.value = ThermalComponentIF::STATE_REQUEST_NON_OPERATIONAL;
       }
-      thermalSet->heaterRequest.setValid(true);
+      // thermalSet->heaterRequest.setValid(true);
     }
   }
   /* TODO: This will probably be done by the LocalDataPoolManager now */
@@ -1468,8 +1467,9 @@ Submode_t DeviceHandlerBase::getInitialSubmode() { return SUBMODE_NONE; }
 
 void DeviceHandlerBase::performOperationHook() {}
 
+/*
 ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                                         LocalDataPoolManager& poolManager) {
+                                                         PeriodicHkGenerationHelper& poolManager) {
   if (thermalStateCfg.has_value()) {
     localDataPoolMap.emplace(thermalStateCfg.value().thermalStatePoolId,
                              new PoolEntry<DeviceHandlerIF::dh_thermal_state_t>());
@@ -1478,6 +1478,7 @@ ReturnValue_t DeviceHandlerBase::initializeLocalDataPool(localpool::DataPool& lo
   }
   return returnvalue::OK;
 }
+ */
 
 ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
   // In this function, the task handle should be valid if the task
@@ -1485,7 +1486,7 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
   if (executingTask != nullptr) {
     pstIntervalMs = executingTask->getPeriodMs();
   }
-  this->poolManager.initializeAfterTaskCreation();
+  // this->poolManager.initializeAfterTaskCreation();
 
   if (thermalStateCfg.has_value()) {
     ThermalStateCfg& cfg = thermalStateCfg.value();
@@ -1497,20 +1498,11 @@ ReturnValue_t DeviceHandlerBase::initializeAfterTaskCreation() {
   return returnvalue::OK;
 }
 
-LocalPoolDataSetBase* DeviceHandlerBase::getDataSetHandle(sid_t sid) {
-  auto iter = deviceReplyMap.find(sid.ownerSetId);
-  if (iter != deviceReplyMap.end()) {
-    return iter->second.dataSet;
-  } else {
-    return nullptr;
-  }
-}
-
 object_id_t DeviceHandlerBase::getObjectId() const { return SystemObject::getObjectId(); }
 
 void DeviceHandlerBase::setStartUpImmediately() { this->setStartupImmediately = true; }
 
-dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const { return pstIntervalMs; }
+// dur_millis_t DeviceHandlerBase::getPeriodicOperationFrequency() const { return pstIntervalMs; }
 
 DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
   if (cookieInfo.pendingCommand != deviceCommandMap.end()) {
@@ -1519,17 +1511,6 @@ DeviceCommandId_t DeviceHandlerBase::getPendingCommand() const {
   return DeviceHandlerIF::NO_COMMAND_ID;
 }
 
-void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() {
-  for (const auto& reply : deviceReplyMap) {
-    if (reply.second.dataSet != nullptr) {
-      PoolReadGuard pg(reply.second.dataSet);
-      if (pg.getReadResult() == returnvalue::OK) {
-        reply.second.dataSet->setValidity(false, true);
-      }
-    }
-  }
-}
-
 void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType, const char* functionName,
                                             ReturnValue_t errorCode, const char* errorPrint) {
   if (errorPrint == nullptr) {
@@ -1570,8 +1551,6 @@ void DeviceHandlerBase::printWarningOrError(sif::OutputTypes errorType, const ch
   }
 }
 
-LocalDataPoolManager* DeviceHandlerBase::getHkManagerHandle() { return &poolManager; }
-
 MessageQueueId_t DeviceHandlerBase::getCommanderQueueId(DeviceCommandId_t replyId) const {
   auto commandIter = deviceCommandMap.find(replyId);
   if (commandIter == deviceCommandMap.end()) {
@@ -1628,3 +1607,7 @@ ReturnValue_t DeviceHandlerBase::finishAction(bool success, DeviceCommandId_t ac
   actionHelper.finish(success, commandIter->second.sendReplyTo, action, result);
   return returnvalue::OK;
 }
+
+void DeviceHandlerBase::setNormalDatapoolEntriesInvalid() { return; }
+
+hk::PeriodicHelper& DeviceHandlerBase::getHkHelper() { return hkHelper; }
diff --git a/src/fsfw/devicehandlers/DeviceHandlerBase.h b/src/fsfw/devicehandlers/DeviceHandlerBase.h
index 08298bdc..659bf9e5 100644
--- a/src/fsfw/devicehandlers/DeviceHandlerBase.h
+++ b/src/fsfw/devicehandlers/DeviceHandlerBase.h
@@ -1,5 +1,6 @@
-#ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
-#define FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_
+#pragma once
+
+#include <fsfw/housekeeping/PeriodicHkHelper.h>
 
 #include <map>
 #include <optional>
@@ -10,9 +11,6 @@
 #include "DeviceHandlerThermalSet.h"
 #include "fsfw/action/ActionHelper.h"
 #include "fsfw/action/HasActionsIF.h"
-#include "fsfw/datapool/PoolVariableIF.h"
-#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
-#include "fsfw/datapoollocal/LocalDataPoolManager.h"
 #include "fsfw/health/HealthHelper.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/modes/HasModesIF.h"
@@ -20,7 +18,6 @@
 #include "fsfw/parameters/ParameterHelper.h"
 #include "fsfw/power/PowerSwitchIF.h"
 #include "fsfw/returnvalues/returnvalue.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
 #include "fsfw/subsystem/ModeTreeConnectionIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
@@ -88,7 +85,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
                           public ModeTreeChildIF,
                           public ModeTreeConnectionIF,
                           public ReceivesParameterMessagesIF,
-                          public HasLocalDataPoolIF {
+                          public hk::GeneratesPeriodicHkIF {
   friend void(Factory::setStaticFrameworkObjectIds)();
 
  public:
@@ -96,7 +93,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * The constructor passes the objectId to the SystemObject().
    *
    * @param setObjectId the ObjectId to pass to the SystemObject() Constructor
-   * @param deviceCommuncation Communcation Interface object which is used
+   * @param deviceCommunication Communication Interface object which is used
    * to implement communication functions
    * @param comCookie This object will be passed to the communication inter-
    * face and can contain user-defined information about the communication.
@@ -109,6 +106,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   void setCustomFdir(FailureIsolationBase *fdir);
   void setPowerSwitcher(PowerSwitchIF *switcher);
 
+  hk::PeriodicHelper &getHkHelper();
+
   /**
    * extending the modes of DeviceHandler IF for internal state machine
    */
@@ -230,7 +229,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   ReturnValue_t initializeAfterTaskCreation() override;
 
   /** Destructor. */
-  virtual ~DeviceHandlerBase();
+  ~DeviceHandlerBase() override;
 
   /**
    * Implementation of ExecutableObjectIF function
@@ -238,7 +237,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param task_ Pointer to the taskIF of this task
    */
   virtual void setTaskIF(PeriodicTaskIF *task_) override;
-  virtual MessageQueueId_t getCommandQueue(void) const override;
+  virtual MessageQueueId_t getCommandQueue() const override;
 
   /** Explicit interface implementation of getObjectId */
   virtual object_id_t getObjectId() const override;
@@ -506,7 +505,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    *          - @c returnvalue::FAILED else.
    */
   ReturnValue_t insertInCommandAndReplyMap(DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
-                                           LocalPoolDataSetBase *replyDataSet = nullptr,
+                                           dp::SharedSetBase *replyDataSet = nullptr,
                                            size_t replyLen = 0, bool periodic = false,
                                            bool hasDifferentReplyId = false,
                                            DeviceCommandId_t replyId = 0,
@@ -527,7 +526,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    *          - @c returnvalue::FAILED else.
    */
   ReturnValue_t insertInReplyMap(DeviceCommandId_t deviceCommand, uint16_t maxDelayCycles,
-                                 LocalPoolDataSetBase *dataSet = nullptr, size_t replyLen = 0,
+                                 dp::SharedSetBase *dataSet = nullptr, size_t replyLen = 0,
                                  bool periodic = false, Countdown *countdown = nullptr);
 
   /**
@@ -580,7 +579,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @details
    * Used by the local data pool manager.
    */
-  ReturnValue_t setReplyDataset(DeviceCommandId_t replyId, LocalPoolDataSetBase *dataset);
+  ReturnValue_t setReplyDataset(DeviceCommandId_t replyId, dp::SharedSetBase *dataset);
 
   /**
    * Get the time needed to transit from modeFrom to modeTo.
@@ -607,8 +606,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @param localDataPoolMap
    * @return
    */
-  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                                LocalDataPoolManager &poolManager) override;
+  // virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+  // PeriodicHkGenerationHelper &poolManager) override;
   /**
    * @brief   Set all datapool variables that are update periodically in
    *          normal mode invalid
@@ -619,15 +618,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * method optionally.
    */
   virtual void setNormalDatapoolEntriesInvalid();
-  /**
-   * @brief   Get the dataset handle for a given SID.
-   * @details
-   * The default implementation will use the deviceCommandMap to look for the corresponding
-   * dataset handle. The user can override this function if this is not desired.
-   * @param sid
-   * @return
-   */
-  virtual LocalPoolDataSetBase *getDataSetHandle(sid_t sid) override;
 
   /* HasModesIF overrides */
   virtual void startTransition(Mode_t mode, Submode_t submode) override;
@@ -797,6 +787,8 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   /** Cookie used for communication */
   CookieIF *comCookie;
 
+  dp::SharedPool sharedPool;
+
   /* Health helper for HasHealthIF */
   HealthHelper healthHelper;
   /* Mode helper for HasModesIF */
@@ -806,7 +798,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
   /* Action helper for HasActionsIF */
   ActionHelper actionHelper;
   /* Housekeeping Manager */
-  LocalDataPoolManager poolManager;
+  hk::PeriodicHelper hkHelper;
 
   /**
    *  @brief Information about commands
@@ -854,7 +846,7 @@ class DeviceHandlerBase : public DeviceHandlerIF,
     //! The dataset used to access housekeeping data related to the
     //! respective device reply. Will point to a dataset held by
     //! the child handler (if one is specified)
-    LocalPoolDataSetBase *dataSet = nullptr;
+    dp::SharedSetBase *dataSet = nullptr;
     //! The command that expects this reply.
     DeviceCommandMap::iterator command;
     //! Instead of using delayCycles to specify the maximum time to wait for the device reply, it
@@ -1006,12 +998,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    */
   virtual void doOnActivity();
 
-  /**
-   * Required for HasLocalDataPoolIF, return a handle to the local pool manager.
-   * @return
-   */
-  LocalDataPoolManager *getHkManagerHandle() override;
-
   const HasHealthIF *getOptHealthIF() const override;
   const HasModesIF &getModeIF() const override;
 
@@ -1403,8 +1389,6 @@ class DeviceHandlerBase : public DeviceHandlerIF,
 
   ReturnValue_t handleDeviceHandlerMessage(CommandMessage *message);
 
-  virtual dur_millis_t getPeriodicOperationFrequency() const override;
-
   void parseReply(const uint8_t *receivedData, size_t receivedDataLen);
 
   void handleTransitionToOnMode(Mode_t commandedMode, Submode_t commandedSubmode);
@@ -1424,6 +1408,4 @@ class DeviceHandlerBase : public DeviceHandlerIF,
    * @brief Disables all commands and replies when device is set to MODE_OFF
    */
   void disableCommandsAndReplies();
-};
-
-#endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERBASE_H_ */
+};
\ No newline at end of file
diff --git a/src/fsfw/devicehandlers/DeviceHandlerIF.h b/src/fsfw/devicehandlers/DeviceHandlerIF.h
index acdb561c..29320200 100644
--- a/src/fsfw/devicehandlers/DeviceHandlerIF.h
+++ b/src/fsfw/devicehandlers/DeviceHandlerIF.h
@@ -2,11 +2,11 @@
 #define FSFW_DEVICEHANDLERS_DEVICEHANDLERIF_H_
 
 #include "../action/HasActionsIF.h"
-#include "../datapoollocal/localPoolDefinitions.h"
 #include "../events/Event.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../modes/HasModesIF.h"
 #include "DeviceHandlerMessage.h"
+#include "fsfw/datapool/definitions.h"
 
 /**
  * This is used to uniquely identify commands that are sent to a device
@@ -120,10 +120,10 @@ class DeviceHandlerIF {
     NOTHING      //!< Do nothing.
   };
 
-  static constexpr uint32_t DEFAULT_THERMAL_SET_ID = sid_t::INVALID_SET_ID - 1;
+  static constexpr uint32_t DEFAULT_THERMAL_SET_ID = dp::sid_t::INVALID_SET_ID - 1;
 
-  static constexpr lp_id_t DEFAULT_THERMAL_STATE_POOL_ID = localpool::INVALID_LPID - 2;
-  static constexpr lp_id_t DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID = localpool::INVALID_LPID - 1;
+  static constexpr dp::id_t DEFAULT_THERMAL_STATE_POOL_ID = dp::INVALID_LPID - 2;
+  static constexpr dp::id_t DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID = dp::INVALID_LPID - 1;
 
   /**
    * Default Destructor
@@ -138,8 +138,8 @@ class DeviceHandlerIF {
 };
 
 struct ThermalStateCfg {
-  lp_id_t thermalStatePoolId = DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID;
-  lp_id_t thermalRequestPoolId = DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID;
+  dp::id_t thermalStatePoolId = DeviceHandlerIF::DEFAULT_THERMAL_STATE_POOL_ID;
+  dp::id_t thermalRequestPoolId = DeviceHandlerIF::DEFAULT_THERMAL_HEATING_REQUEST_POOL_ID;
   uint32_t thermalSetId = DeviceHandlerIF::DEFAULT_THERMAL_SET_ID;
 };
 
diff --git a/src/fsfw/devicehandlers/DeviceHandlerThermalSet.h b/src/fsfw/devicehandlers/DeviceHandlerThermalSet.h
index 49ebd5f4..cf384694 100644
--- a/src/fsfw/devicehandlers/DeviceHandlerThermalSet.h
+++ b/src/fsfw/devicehandlers/DeviceHandlerThermalSet.h
@@ -1,27 +1,29 @@
 #ifndef FSFW_DEVICEHANDLERS_DEVICEHANDLERTHERMALSET_H_
 #define FSFW_DEVICEHANDLERS_DEVICEHANDLERTHERMALSET_H_
 
-#include "../datapoollocal/LocalPoolVariable.h"
-#include "../datapoollocal/StaticLocalDataSet.h"
-#include "DeviceHandlerIF.h"
+#include <fsfw/datapool/StaticSharedSet.h>
+#include <fsfw/housekeeping/GeneratesPeriodicHkIF.h>
 
-class DeviceHandlerThermalSet : public StaticLocalDataSet<2> {
+#include "DeviceHandlerIF.h"
+#include "fsfw/datapool/PoolVariable.h"
+
+class DeviceHandlerThermalSet : public dp::StaticSharedSet<2> {
  public:
-  DeviceHandlerThermalSet(HasLocalDataPoolIF* hkOwner, ThermalStateCfg cfg)
+  DeviceHandlerThermalSet(hk::GeneratesPeriodicHkIF* hkOwner, ThermalStateCfg cfg)
       : DeviceHandlerThermalSet(hkOwner->getObjectId(), cfg) {}
 
   DeviceHandlerThermalSet(object_id_t deviceHandler, ThermalStateCfg cfg)
-      : StaticLocalDataSet(sid_t(deviceHandler, cfg.thermalSetId)),
+      : StaticSharedSet(dp::structure_id_t(deviceHandler, cfg.thermalSetId)),
         thermalStatePoolId(cfg.thermalStatePoolId),
         heaterRequestPoolId(cfg.thermalRequestPoolId) {}
 
-  const lp_id_t thermalStatePoolId;
-  const lp_id_t heaterRequestPoolId;
+  const dp::id_t thermalStatePoolId;
+  const dp::id_t heaterRequestPoolId;
 
-  lp_var_t<DeviceHandlerIF::dh_thermal_state_t> thermalState =
-      lp_var_t<DeviceHandlerIF::dh_thermal_state_t>(sid.objectId, thermalStatePoolId, this);
-  lp_var_t<DeviceHandlerIF::dh_heater_request_t> heaterRequest =
-      lp_var_t<DeviceHandlerIF::dh_heater_request_t>(sid.objectId, heaterRequestPoolId, this);
+  dp::var_t<DeviceHandlerIF::dh_thermal_state_t> thermalState =
+      dp::var_t<DeviceHandlerIF::dh_thermal_state_t>(sid.objectId, thermalStatePoolId, this);
+  dp::var_t<DeviceHandlerIF::dh_heater_request_t> heaterRequest =
+      dp::var_t<DeviceHandlerIF::dh_heater_request_t>(sid.objectId, heaterRequestPoolId, this);
 };
 
 #endif /* FSFW_DEVICEHANDLERS_DEVICEHANDLERTHERMALSET_H_ */
diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp
index 1aa4431c..a245fa5f 100644
--- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp
+++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.cpp
@@ -8,12 +8,12 @@ FreshDeviceHandlerBase::FreshDeviceHandlerBase(DhbConfig config)
     : SystemObject(config.objectId),
       actionHelper(this, nullptr),
       modeHelper(this),
-      healthHelper(this, getObjectId()),
+      healthHelper(this, FreshDeviceHandlerBase::getObjectId()),
       paramHelper(this),
-      poolManager(this, nullptr),
+      hkHelper(this, nullptr),
       fdirInstance(config.fdirInstance),
       defaultFdirParent(config.defaultFdirParent) {
-  auto mqArgs = MqArgs(config.objectId, static_cast<void*>(this));
+  auto mqArgs = MqArgs(config.objectId, this);
   messageQueue = QueueFactory::instance()->createMessageQueue(
       config.msgQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
@@ -33,7 +33,7 @@ ReturnValue_t FreshDeviceHandlerBase::performOperation(uint8_t opCode) {
   handleQueue();
   fdirInstance->checkForFailures();
   performDeviceOperation(opCode);
-  poolManager.performHkOperation();
+  hkHelper.performHkOperation();
   return returnvalue::OK;
 }
 
@@ -43,7 +43,6 @@ ReturnValue_t FreshDeviceHandlerBase::performDeviceOperationPreQueueHandling(uin
 
 void FreshDeviceHandlerBase::startTransition(Mode_t mode_, Submode_t submode_) {
   triggerEvent(CHANGING_MODE, mode_, submode_);
-  // Complete mode transition immediately by default.
   setMode(mode_, submode_);
 }
 
@@ -97,7 +96,7 @@ ReturnValue_t FreshDeviceHandlerBase::handleQueue() {
       continue;
     }
 
-    result = poolManager.handleHousekeepingMessage(&command);
+    result = hkHelper.handleHousekeepingMessage(&command);
     if (result == returnvalue::OK) {
       continue;
     }
@@ -127,17 +126,6 @@ ReturnValue_t FreshDeviceHandlerBase::connectModeTreeParent(HasModeTreeChildrenI
 // Executable Overrides.
 void FreshDeviceHandlerBase::setTaskIF(PeriodicTaskIF* task_) { executingTask = task_; }
 
-// Pool Manager overrides.
-LocalDataPoolManager* FreshDeviceHandlerBase::getHkManagerHandle() { return &poolManager; }
-
-[[nodiscard]] uint32_t FreshDeviceHandlerBase::getPeriodicOperationFrequency() const {
-  return this->executingTask->getPeriodMs();
-}
-
-ReturnValue_t FreshDeviceHandlerBase::initializeAfterTaskCreation() {
-  return poolManager.initializeAfterTaskCreation();
-}
-
 ReturnValue_t FreshDeviceHandlerBase::setHealth(HasHealthIF::HealthState health) {
   // Assembly should handle commanding to OFF.
   healthHelper.setHealth(health);
@@ -174,7 +162,7 @@ ReturnValue_t FreshDeviceHandlerBase::initialize() {
     return result;
   }
 
-  result = poolManager.initialize(messageQueue);
+  result = hkHelper.initialize(messageQueue);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -201,3 +189,5 @@ ReturnValue_t FreshDeviceHandlerBase::getParameter(uint8_t domainId, uint8_t uni
   }
   return INVALID_DOMAIN_ID;
 }
+
+datapool::SharedPool* FreshDeviceHandlerBase::getOptionalSharedPool() { return nullptr; }
\ No newline at end of file
diff --git a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h
index f69113ff..b0348a9f 100644
--- a/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h
+++ b/src/fsfw/devicehandlers/FreshDeviceHandlerBase.h
@@ -1,12 +1,13 @@
 #pragma once
 
+#include <fsfw/housekeeping/PeriodicHkHelper.h>
+
 #include "fsfw/action.h"
-#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
-#include "fsfw/datapoollocal/LocalDataPoolManager.h"
 #include "fsfw/devicehandlers/DeviceHandlerIF.h"
 #include "fsfw/fdir/FailureIsolationBase.h"
 #include "fsfw/health/HasHealthIF.h"
 #include "fsfw/health/HealthHelper.h"
+#include "fsfw/housekeeping/GeneratesPeriodicHkIF.h"
 #include "fsfw/modes/HasModesIF.h"
 #include "fsfw/objectmanager.h"
 #include "fsfw/parameters/ParameterHelper.h"
@@ -34,7 +35,7 @@ class FreshDeviceHandlerBase : public SystemObject,
                                public ModeTreeConnectionIF,
                                public HasActionsIF,
                                public ReceivesParameterMessagesIF,
-                               public HasLocalDataPoolIF {
+                               public hk::GeneratesPeriodicHkIF {
  public:
   explicit FreshDeviceHandlerBase(DhbConfig config);
   ~FreshDeviceHandlerBase() override;
@@ -56,16 +57,12 @@ class FreshDeviceHandlerBase : public SystemObject,
   ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent) override;
   ModeTreeChildIF& getModeTreeChildIF() override;
 
-  [[nodiscard]] uint32_t getPeriodicOperationFrequency() const override;
-
  protected:
-  // Pool Manager overrides.
-  LocalDataPoolManager* getHkManagerHandle() override;
   ActionHelper actionHelper;
   ModeHelper modeHelper;
   HealthHelper healthHelper;
   ParameterHelper paramHelper;
-  LocalDataPoolManager poolManager;
+  hk::PeriodicHelper hkHelper;
 
   bool hasCustomFdir = false;
   FailureIsolationBase* fdirInstance;
@@ -107,6 +104,13 @@ class FreshDeviceHandlerBase : public SystemObject,
   // System Object overrides.
   ReturnValue_t initialize() override;
 
+  // Default implementation assumes that no optional shared pool is required.
+  virtual datapool::SharedPool* getOptionalSharedPool();
+
+  // Implemented by child, required for periodic HK.
+  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
    * not health, mode, action or housekeeping messages.
@@ -115,11 +119,6 @@ class FreshDeviceHandlerBase : public SystemObject,
    */
   virtual ReturnValue_t handleCommandMessage(CommandMessage* message) = 0;
 
-  // HK manager abstract functions.
-  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override = 0;
-  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                        LocalDataPoolManager& poolManager) override = 0;
-
   // Mode abstract functions
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                  uint32_t* msToReachTheMode) override = 0;
@@ -129,8 +128,7 @@ class FreshDeviceHandlerBase : public SystemObject,
   ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                               const uint8_t* data, size_t size) override = 0;
   // Executable overrides.
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
-  ReturnValue_t initializeAfterTaskCreation() override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
 
   /**
    * This calls the FDIR instance event trigger function.
diff --git a/src/fsfw/housekeeping/CMakeLists.txt b/src/fsfw/housekeeping/CMakeLists.txt
index 236d3204..ac39ba35 100644
--- a/src/fsfw/housekeeping/CMakeLists.txt
+++ b/src/fsfw/housekeeping/CMakeLists.txt
@@ -1,2 +1,2 @@
 target_sources(${LIB_FSFW_NAME} PRIVATE HousekeepingMessage.cpp
-                                        PeriodicHousekeepingHelper.cpp)
+                                        PeriodicHkHelper.cpp)
diff --git a/src/fsfw/housekeeping/GeneratesPeriodicHkIF.h b/src/fsfw/housekeeping/GeneratesPeriodicHkIF.h
new file mode 100644
index 00000000..339ee087
--- /dev/null
+++ b/src/fsfw/housekeeping/GeneratesPeriodicHkIF.h
@@ -0,0 +1,65 @@
+#pragma once
+
+#include <fsfw/datapool/SharedPool.h>
+
+#include <vector>
+
+#include "definitions.h"
+#include "fsfw/datapool/definitions.h"
+
+namespace hk {
+
+/**
+ * @brief 		This interface is implemented by classes which posses a local data pool (not
+ * the managing class). It defines the relationship between the local data pool owner and the
+ * LocalDataPoolManager.
+ * @details
+ * Any class implementing this interface shall also have a LocalDataPoolManager member class which
+ * contains the actual pool data structure and exposes the public interface for it.
+ *
+ * The local data pool can be accessed using helper classes by using the
+ * LocalPoolVariable, LocalPoolVector or LocalDataSet classes. Every local pool variable can
+ * be uniquely identified by a global pool ID (gp_id_t) and every dataset tied
+ * to a pool manager can be uniqely identified by a global structure ID (sid_t).
+ *
+ * All software objects which want to use the local pool of another object shall also use this
+ * interface, for example to get a handle to the subscription interface. The interface
+ * can be retrieved using the object manager, provided the target object is a SystemObject.
+ * For example, the following line of code can be used to retrieve the interface
+ *
+ *    HasLocalDataPoolIF* poolIF = ObjectManager::instance()->
+ *             get<HasLocalDataPoolIF>(objects::SOME_OBJECT);
+ *    if(poolIF != nullptr) {
+ *        doSomething()
+ *    }
+ */
+class GeneratesPeriodicHkIF {
+  friend class PeriodicHelper;
+
+ public:
+  [[nodiscard]] virtual object_id_t getObjectId() const = 0;
+
+  /** Command queue for housekeeping messages. */
+  [[nodiscard]] virtual MessageQueueId_t getCommandQueue() const = 0;
+
+  virtual datapool::SharedPool* getOptionalSharedPool() = 0;
+
+ protected:
+  virtual ~GeneratesPeriodicHkIF() = default;
+
+  static constexpr uint32_t INVALID_LPID = dp::INVALID_LPID;
+
+  virtual ReturnValue_t serializeHkDataset(dp::sid_t structureId, uint8_t* buf, size_t maxSize) = 0;
+  virtual ReturnValue_t specifyHkDatasets(std::vector<hk::SetSpecification>& setList) = 0;
+
+  /**
+   * These function can be implemented by pool owner, if they are required
+   * and used by the housekeeping message interface.
+   * */
+  virtual ReturnValue_t addDataSet(dp::sid_t sid) { return returnvalue::FAILED; };
+  virtual ReturnValue_t removeDataSet(dp::sid_t sid) { return returnvalue::FAILED; };
+  virtual ReturnValue_t changeCollectionInterval(dp::sid_t sid, float newIntervalSeconds) {
+    return returnvalue::FAILED;
+  };
+};
+}  // namespace hk
\ No newline at end of file
diff --git a/src/fsfw/housekeeping/HousekeepingMessage.cpp b/src/fsfw/housekeeping/HousekeepingMessage.cpp
index aa457d5c..8e2b9a88 100644
--- a/src/fsfw/housekeeping/HousekeepingMessage.cpp
+++ b/src/fsfw/housekeeping/HousekeepingMessage.cpp
@@ -1,12 +1,14 @@
 #include "fsfw/housekeeping/HousekeepingMessage.h"
 
+#include <fsfw/timemanager/clockDefinitions.h>
+
 #include <cstring>
 
 #include "fsfw/objectmanager/ObjectManager.h"
 
 HousekeepingMessage::~HousekeepingMessage() {}
 
-void HousekeepingMessage::setHkReportReply(CommandMessage *message, sid_t sid,
+void HousekeepingMessage::setHkReportReply(CommandMessage *message, dp::structure_id_t sid,
                                            store_address_t storeId) {
   message->setCommand(HK_REPORT);
   message->setMessageSize(HK_MESSAGE_SIZE);
@@ -14,15 +16,15 @@ void HousekeepingMessage::setHkReportReply(CommandMessage *message, sid_t sid,
   message->setParameter3(storeId.raw);
 }
 
-sid_t HousekeepingMessage::getHkDataReply(const CommandMessage *message,
-                                          store_address_t *storeIdToSet) {
+dp::structure_id_t HousekeepingMessage::getHkDataReply(const CommandMessage *message,
+                                                       store_address_t *storeIdToSet) {
   if (storeIdToSet != nullptr) {
     *storeIdToSet = message->getParameter3();
   }
-  return getSid(message);
+  return getStructureId(message);
 }
 
-void HousekeepingMessage::setToggleReportingCommand(CommandMessage *message, sid_t sid,
+void HousekeepingMessage::setToggleReportingCommand(CommandMessage *message, dp::structure_id_t sid,
                                                     bool enableReporting) {
   if (enableReporting) {
     message->setCommand(ENABLE_PERIODIC_HK_REPORT_GENERATION);
@@ -33,74 +35,72 @@ void HousekeepingMessage::setToggleReportingCommand(CommandMessage *message, sid
   setSid(message, sid);
 }
 
-void HousekeepingMessage::setStructureReportingCommand(CommandMessage *command, sid_t sid) {
+void HousekeepingMessage::setStructureReportingCommand(CommandMessage *command,
+                                                       dp::structure_id_t sid) {
   command->setCommand(REPORT_HK_REPORT_STRUCTURES);
 
   setSid(command, sid);
 }
 
-void HousekeepingMessage::setOneShotReportCommand(CommandMessage *command, sid_t sid) {
+void HousekeepingMessage::setOneShotReportCommand(CommandMessage *command, dp::structure_id_t sid) {
   command->setCommand(GENERATE_ONE_PARAMETER_REPORT);
 
   setSid(command, sid);
 }
 
-void HousekeepingMessage::setCollectionIntervalModificationCommand(CommandMessage *command,
-                                                                   sid_t sid,
-                                                                   float collectionInterval) {
+void HousekeepingMessage::setCollectionIntervalModificationCommand(
+    CommandMessage *command, dp::structure_id_t sid, dur_millis_t collectionIntervalMs) {
   command->setCommand(MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL);
 
   /* Raw storage of the float in the message. Do not use setParameter3, does
   implicit conversion to integer type! */
-  std::memcpy(command->getData() + 2 * sizeof(uint32_t), &collectionInterval,
-              sizeof(collectionInterval));
+  std::memcpy(command->getData() + 2 * sizeof(uint32_t), &collectionIntervalMs,
+              sizeof(collectionIntervalMs));
 
   setSid(command, sid);
 }
 
-sid_t HousekeepingMessage::getCollectionIntervalModificationCommand(const CommandMessage *command,
-                                                                    float *newCollectionInterval) {
-  if (newCollectionInterval != nullptr) {
-    std::memcpy(newCollectionInterval, command->getData() + 2 * sizeof(uint32_t),
-                sizeof(*newCollectionInterval));
-  }
+dp::structure_id_t HousekeepingMessage::getCollectionIntervalModificationCommand(
+    const CommandMessage *command, dur_millis_t &newCollectionIntervalMs) {
+  std::memcpy(&newCollectionIntervalMs, command->getData() + 2 * sizeof(uint32_t),
+              sizeof(newCollectionIntervalMs));
 
-  return getSid(command);
+  return getStructureId(command);
 }
 
-void HousekeepingMessage::setHkRequestSuccessReply(CommandMessage *reply, sid_t sid) {
+void HousekeepingMessage::setHkRequestSuccessReply(CommandMessage *reply, dp::structure_id_t sid) {
   setSid(reply, sid);
   reply->setCommand(HK_REQUEST_SUCCESS);
 }
 
-void HousekeepingMessage::setHkRequestFailureReply(CommandMessage *reply, sid_t sid,
+void HousekeepingMessage::setHkRequestFailureReply(CommandMessage *reply, dp::structure_id_t sid,
                                                    ReturnValue_t error) {
   setSid(reply, sid);
   reply->setCommand(HK_REQUEST_FAILURE);
   reply->setParameter3(error);
 }
 
-sid_t HousekeepingMessage::getHkRequestFailureReply(const CommandMessage *reply,
-                                                    ReturnValue_t *error) {
+dp::structure_id_t HousekeepingMessage::getHkRequestFailureReply(const CommandMessage *reply,
+                                                                 ReturnValue_t *error) {
   if (error != nullptr) {
     *error = reply->getParameter3();
   }
-  return getSid(reply);
+  return getStructureId(reply);
 }
 
-sid_t HousekeepingMessage::getSid(const CommandMessage *message) {
-  sid_t sid;
+dp::structure_id_t HousekeepingMessage::getStructureId(const CommandMessage *message) {
+  dp::structure_id_t sid;
   std::memcpy(&sid.raw, message->getData(), sizeof(sid.raw));
   return sid;
 }
 
-gp_id_t HousekeepingMessage::getGpid(const CommandMessage *message) {
-  gp_id_t globalPoolId;
+dp::g_id_t HousekeepingMessage::getGpid(const CommandMessage *message) {
+  dp::g_id_t globalPoolId;
   std::memcpy(&globalPoolId.raw, message->getData(), sizeof(globalPoolId.raw));
   return globalPoolId;
 }
 
-void HousekeepingMessage::setHkStuctureReportReply(CommandMessage *reply, sid_t sid,
+void HousekeepingMessage::setHkStuctureReportReply(CommandMessage *reply, dp::structure_id_t sid,
                                                    store_address_t storeId) {
   reply->setCommand(HK_DEFINITIONS_REPORT);
   setSid(reply, sid);
@@ -111,13 +111,10 @@ void HousekeepingMessage::clear(CommandMessage *message) {
   switch (message->getCommand()) {
     case (HK_REPORT):
     case (DIAGNOSTICS_REPORT):
-    case (HK_DEFINITIONS_REPORT):
-    case (UPDATE_SNAPSHOT_SET):
-    case (UPDATE_SNAPSHOT_VARIABLE): {
+    case (HK_DEFINITIONS_REPORT): {
       store_address_t storeId;
       getHkDataReply(message, &storeId);
-      StorageManagerIF *ipcStore =
-          ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
+      auto *ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
       if (ipcStore != nullptr) {
         ipcStore->deleteData(storeId);
       }
@@ -126,60 +123,36 @@ void HousekeepingMessage::clear(CommandMessage *message) {
   message->setCommand(CommandMessage::CMD_NONE);
 }
 
-void HousekeepingMessage::setUpdateNotificationSetCommand(CommandMessage *command, sid_t sid) {
-  command->setCommand(UPDATE_NOTIFICATION_SET);
-  setSid(command, sid);
+dp::structure_id_t HousekeepingMessage::getUpdateNotificationSetCommand(
+    const CommandMessage *command) {
+  return getStructureId(command);
 }
 
-void HousekeepingMessage::setUpdateNotificationVariableCommand(CommandMessage *command,
-                                                               gp_id_t globalPoolId) {
-  command->setCommand(UPDATE_NOTIFICATION_VARIABLE);
-  setGpid(command, globalPoolId);
-}
-
-void HousekeepingMessage::setUpdateSnapshotSetCommand(CommandMessage *command, sid_t sid,
-                                                      store_address_t storeId) {
-  command->setCommand(UPDATE_SNAPSHOT_SET);
-  setSid(command, sid);
-  command->setParameter3(storeId.raw);
-}
-
-void HousekeepingMessage::setUpdateSnapshotVariableCommand(CommandMessage *command,
-                                                           gp_id_t globalPoolId,
-                                                           store_address_t storeId) {
-  command->setCommand(UPDATE_SNAPSHOT_VARIABLE);
-  setGpid(command, globalPoolId);
-  command->setParameter3(storeId.raw);
-}
-
-sid_t HousekeepingMessage::getUpdateNotificationSetCommand(const CommandMessage *command) {
-  return getSid(command);
-}
-
-gp_id_t HousekeepingMessage::getUpdateNotificationVariableCommand(const CommandMessage *command) {
+dp::g_id_t HousekeepingMessage::getUpdateNotificationVariableCommand(
+    const CommandMessage *command) {
   return getGpid(command);
 }
 
-sid_t HousekeepingMessage::getUpdateSnapshotSetCommand(const CommandMessage *command,
-                                                       store_address_t *storeId) {
+dp::structure_id_t HousekeepingMessage::getUpdateSnapshotSetCommand(const CommandMessage *command,
+                                                                    store_address_t *storeId) {
   if (storeId != nullptr) {
     *storeId = command->getParameter3();
   }
-  return getSid(command);
+  return getStructureId(command);
 }
 
-gp_id_t HousekeepingMessage::getUpdateSnapshotVariableCommand(const CommandMessage *command,
-                                                              store_address_t *storeId) {
+dp::g_id_t HousekeepingMessage::getUpdateSnapshotVariableCommand(const CommandMessage *command,
+                                                                 store_address_t *storeId) {
   if (storeId != nullptr) {
     *storeId = command->getParameter3();
   }
   return getGpid(command);
 }
 
-void HousekeepingMessage::setSid(CommandMessage *message, sid_t sid) {
+void HousekeepingMessage::setSid(CommandMessage *message, dp::structure_id_t sid) {
   std::memcpy(message->getData(), &sid.raw, sizeof(sid.raw));
 }
 
-void HousekeepingMessage::setGpid(CommandMessage *message, gp_id_t globalPoolId) {
+void HousekeepingMessage::setGpid(CommandMessage *message, dp::g_id_t globalPoolId) {
   std::memcpy(message->getData(), &globalPoolId.raw, sizeof(globalPoolId.raw));
 }
diff --git a/src/fsfw/housekeeping/HousekeepingMessage.h b/src/fsfw/housekeeping/HousekeepingMessage.h
index 4cc8c317..bb2d27b8 100644
--- a/src/fsfw/housekeeping/HousekeepingMessage.h
+++ b/src/fsfw/housekeeping/HousekeepingMessage.h
@@ -1,7 +1,9 @@
 #ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 #define FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_
 
-#include "fsfw/datapoollocal/localPoolDefinitions.h"
+#include <fsfw/timemanager/clockDefinitions.h>
+
+#include "fsfw/datapool/definitions.h"
 #include "fsfw/ipc/CommandMessage.h"
 #include "fsfw/ipc/FwMessageTypes.h"
 #include "fsfw/objectmanager/frameworkObjects.h"
@@ -16,7 +18,7 @@
 class HousekeepingMessage {
  public:
   static constexpr size_t HK_MESSAGE_SIZE =
-      CommandMessageIF::HEADER_SIZE + sizeof(sid_t) + sizeof(uint32_t);
+      CommandMessageIF::HEADER_SIZE + sizeof(dp::structure_id_t) + sizeof(uint32_t);
 
   /**
    * Concrete instance is not used, instead this class operates on
@@ -44,33 +46,35 @@ class HousekeepingMessage {
   static constexpr Command_t HK_REQUEST_SUCCESS = MAKE_COMMAND_ID(128);
   static constexpr Command_t HK_REQUEST_FAILURE = MAKE_COMMAND_ID(129);
 
-  static constexpr Command_t UPDATE_NOTIFICATION_SET = MAKE_COMMAND_ID(130);
-  static constexpr Command_t UPDATE_NOTIFICATION_VARIABLE = MAKE_COMMAND_ID(131);
+  // static constexpr Command_t UPDATE_NOTIFICATION_SET = MAKE_COMMAND_ID(130);
+  // static constexpr Command_t UPDATE_NOTIFICATION_VARIABLE = MAKE_COMMAND_ID(131);
 
-  static constexpr Command_t UPDATE_SNAPSHOT_SET = MAKE_COMMAND_ID(132);
-  static constexpr Command_t UPDATE_SNAPSHOT_VARIABLE = MAKE_COMMAND_ID(133);
+  // static constexpr Command_t UPDATE_SNAPSHOT_SET = MAKE_COMMAND_ID(132);
+  // static constexpr Command_t UPDATE_SNAPSHOT_VARIABLE = MAKE_COMMAND_ID(133);
 
   // static constexpr Command_t UPDATE_HK_REPORT = MAKE_COMMAND_ID(134);
 
-  static sid_t getSid(const CommandMessage* message);
-  static gp_id_t getGpid(const CommandMessage* message);
+  static dp::sid_t getStructureId(const CommandMessage* message);
+  static dp::g_id_t getGpid(const CommandMessage* message);
 
   /* Housekeeping Interface Messages */
 
-  static void setToggleReportingCommand(CommandMessage* command, sid_t sid, bool enableReporting);
-  static void setStructureReportingCommand(CommandMessage* command, sid_t sid);
-  static void setOneShotReportCommand(CommandMessage* command, sid_t sid);
-  static void setCollectionIntervalModificationCommand(CommandMessage* command, sid_t sid,
-                                                       float collectionInterval);
+  static void setToggleReportingCommand(CommandMessage* command, dp::sid_t sid,
+                                        bool enableReporting);
+  static void setStructureReportingCommand(CommandMessage* command, dp::sid_t sid);
+  static void setOneShotReportCommand(CommandMessage* command, dp::sid_t sid);
+  static void setCollectionIntervalModificationCommand(CommandMessage* command, dp::sid_t sid,
+                                                       dur_millis_t collectionIntervalMs);
 
-  static void setHkReportReply(CommandMessage* reply, sid_t sid, store_address_t storeId);
+  static void setHkReportReply(CommandMessage* reply, dp::sid_t sid, store_address_t storeId);
 
-  static void setHkRequestSuccessReply(CommandMessage* reply, sid_t sid);
-  static void setHkRequestFailureReply(CommandMessage* reply, sid_t sid, ReturnValue_t error);
+  static void setHkRequestSuccessReply(CommandMessage* reply, dp::sid_t sid);
+  static void setHkRequestFailureReply(CommandMessage* reply, dp::sid_t sid, ReturnValue_t error);
 
-  static void setHkStuctureReportReply(CommandMessage* reply, sid_t sid, store_address_t storeId);
+  static void setHkStuctureReportReply(CommandMessage* reply, dp::sid_t sid,
+                                       store_address_t storeId);
 
-  static sid_t getHkRequestFailureReply(const CommandMessage* reply, ReturnValue_t* error);
+  static dp::sid_t getHkRequestFailureReply(const CommandMessage* reply, ReturnValue_t* error);
 
   /**
    * @brief	Generic getter function for housekeeping data replies
@@ -79,33 +83,35 @@ class HousekeepingMessage {
    * regular HK packets. This getter function should be used for the
    * command IDs 10, 12, 25 and 26.
    */
-  static sid_t getHkDataReply(const CommandMessage* message, store_address_t* storeIdToSet);
-  static sid_t getCollectionIntervalModificationCommand(const CommandMessage* command,
-                                                        float* newCollectionInterval);
+  static dp::sid_t getHkDataReply(const CommandMessage* message, store_address_t* storeIdToSet);
+  static dp::sid_t getCollectionIntervalModificationCommand(const CommandMessage* command,
+                                                            dur_millis_t& newCollectionInterval);
 
   /* Update Notification Messages */
 
-  static void setUpdateNotificationSetCommand(CommandMessage* command, sid_t sid);
-  static void setUpdateNotificationVariableCommand(CommandMessage* command, gp_id_t globalPoolId);
+  static void setUpdateNotificationSetCommand(CommandMessage* command, dp::sid_t sid);
+  static void setUpdateNotificationVariableCommand(CommandMessage* command,
+                                                   dp::g_id_t globalPoolId);
 
-  static void setUpdateSnapshotSetCommand(CommandMessage* command, sid_t sid,
+  static void setUpdateSnapshotSetCommand(CommandMessage* command, dp::sid_t sid,
                                           store_address_t storeId);
-  static void setUpdateSnapshotVariableCommand(CommandMessage* command, gp_id_t globalPoolId,
+  static void setUpdateSnapshotVariableCommand(CommandMessage* command, dp::g_id_t globalPoolId,
                                                store_address_t storeId);
 
-  static sid_t getUpdateNotificationSetCommand(const CommandMessage* command);
-  static gp_id_t getUpdateNotificationVariableCommand(const CommandMessage* command);
+  static dp::sid_t getUpdateNotificationSetCommand(const CommandMessage* command);
+  static dp::g_id_t getUpdateNotificationVariableCommand(const CommandMessage* command);
 
-  static sid_t getUpdateSnapshotSetCommand(const CommandMessage* command, store_address_t* storeId);
-  static gp_id_t getUpdateSnapshotVariableCommand(const CommandMessage* command,
-                                                  store_address_t* storeId);
+  static dp::sid_t getUpdateSnapshotSetCommand(const CommandMessage* command,
+                                               store_address_t* storeId);
+  static dp::g_id_t getUpdateSnapshotVariableCommand(const CommandMessage* command,
+                                                     store_address_t* storeId);
 
   /** Utility */
   static void clear(CommandMessage* message);
 
  private:
-  static void setSid(CommandMessage* message, sid_t sid);
-  static void setGpid(CommandMessage* message, gp_id_t globalPoolId);
+  static void setSid(CommandMessage* message, dp::sid_t sid);
+  static void setGpid(CommandMessage* message, dp::g_id_t globalPoolId);
 };
 
 #endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGMESSAGE_H_ */
diff --git a/src/fsfw/housekeeping/HousekeepingPacketDownlink.h b/src/fsfw/housekeeping/HousekeepingPacketDownlink.h
index 0683aa19..4ca9fd09 100644
--- a/src/fsfw/housekeeping/HousekeepingPacketDownlink.h
+++ b/src/fsfw/housekeeping/HousekeepingPacketDownlink.h
@@ -1,9 +1,9 @@
-#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
-#define FSFW_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_
+#pragma once
 
-#include "../datapoollocal/LocalPoolDataSetBase.h"
-#include "../serialize/SerialLinkedListAdapter.h"
-#include "../storagemanager/StorageManagerIF.h"
+#include <fsfw/serialize/SerialBufferAdapter.h>
+
+#include "fsfw/datapool/SharedSetBase.h"
+#include "fsfw/serialize/SerialLinkedListAdapter.h"
 
 /**
  * @brief   This class will be used to serialize general housekeeping packets
@@ -18,8 +18,8 @@
  */
 class HousekeepingPacketDownlink : public SerialLinkedListAdapter<SerializeIF> {
  public:
-  HousekeepingPacketDownlink(sid_t sid, LocalPoolDataSetBase* dataSetPtr)
-      : sourceId(sid.objectId), setId(sid.ownerSetId), hkData(dataSetPtr) {
+  HousekeepingPacketDownlink(dp::sid_t sid, const uint8_t* hkData, size_t hkDataLen)
+      : sourceId(sid.objectId), setId(sid.ownerSetId), hkData(hkData, hkDataLen) {
     setLinks();
   }
 
@@ -32,7 +32,5 @@ class HousekeepingPacketDownlink : public SerialLinkedListAdapter<SerializeIF> {
 
   SerializeElement<object_id_t> sourceId;
   SerializeElement<uint32_t> setId;
-  LinkedElement<SerializeIF> hkData;
-};
-
-#endif /* FRAMEWORK_HOUSEKEEPING_HOUSEKEEPINGPACKETDOWNLINK_H_ */
+  SerializeElement<SerialBufferAdapter<uint32_t>> hkData;
+};
\ No newline at end of file
diff --git a/src/fsfw/housekeeping/HousekeepingSetPacket.h b/src/fsfw/housekeeping/HousekeepingSetPacket.h
index fa039da8..97f02b56 100644
--- a/src/fsfw/housekeeping/HousekeepingSetPacket.h
+++ b/src/fsfw/housekeeping/HousekeepingSetPacket.h
@@ -1,60 +1,28 @@
-#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_
-#define FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_
+#pragma once
 
-#include "../datapoollocal/LocalPoolDataSetBase.h"
-#include "../housekeeping/HousekeepingMessage.h"
-#include "../serialize/SerialLinkedListAdapter.h"
+#include "fsfw/serialize/SerialLinkedListAdapter.h"
 
 class HousekeepingSetPacket : public SerialLinkedListAdapter<SerializeIF> {
  public:
-  HousekeepingSetPacket(sid_t sid, bool reportingEnabled, bool valid, float collectionInterval,
-                        LocalPoolDataSetBase* dataSetPtr)
+  HousekeepingSetPacket(dp::sid_t sid, bool reportingEnabled, dur_millis_t collectionIntervalMs)
       : objectId(sid.objectId),
         setId(sid.ownerSetId),
         reportingEnabled(reportingEnabled),
-        valid(valid),
-        collectionIntervalSeconds(collectionInterval),
-        dataSet(dataSetPtr) {
+        collectionIntervalMs(collectionIntervalMs) {
     setLinks();
   }
 
-  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          Endianness streamEndianness) const override {
-    ReturnValue_t result =
-        SerialLinkedListAdapter::serialize(buffer, size, maxSize, streamEndianness);
-    if (result != returnvalue::OK) {
-      return result;
-    }
-    return dataSet->serializeLocalPoolIds(buffer, size, maxSize, streamEndianness);
-  }
-
-  size_t getSerializedSize() const override {
-    size_t linkedSize = SerialLinkedListAdapter::getSerializedSize();
-    linkedSize += dataSet->getLocalPoolIdsSerializedSize();
-    return linkedSize;
-  }
-
-  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-                            Endianness streamEndianness) override {
-    return returnvalue::OK;
-  }
-
  private:
   void setLinks() {
     setStart(&objectId);
     objectId.setNext(&setId);
     setId.setNext(&reportingEnabled);
-    reportingEnabled.setNext(&valid);
-    valid.setNext(&collectionIntervalSeconds);
-    collectionIntervalSeconds.setEnd();
+    reportingEnabled.setNext(&collectionIntervalMs);
+    collectionIntervalMs.setEnd();
   }
 
   SerializeElement<object_id_t> objectId;
   SerializeElement<uint32_t> setId;
   SerializeElement<bool> reportingEnabled;
-  SerializeElement<bool> valid;
-  SerializeElement<float> collectionIntervalSeconds;
-  LocalPoolDataSetBase* dataSet;
-};
-
-#endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGSETPACKET_H_ */
+  SerializeElement<uint32_t> collectionIntervalMs;
+};
\ No newline at end of file
diff --git a/src/fsfw/housekeeping/HousekeepingSnapshot.h b/src/fsfw/housekeeping/HousekeepingSnapshot.h
index 7e31c464..dd2fbf71 100644
--- a/src/fsfw/housekeeping/HousekeepingSnapshot.h
+++ b/src/fsfw/housekeeping/HousekeepingSnapshot.h
@@ -1,11 +1,10 @@
-#ifndef FSFW_HOUSEKEEPING_HOUSEKEEPINGSNAPSHOT_H_
-#define FSFW_HOUSEKEEPING_HOUSEKEEPINGSNAPSHOT_H_
+#pragma once
 
-#include "../datapoollocal/LocalPoolDataSetBase.h"
-#include "../datapoollocal/LocalPoolObjectBase.h"
-#include "../serialize/SerialBufferAdapter.h"
-#include "../serialize/SerialLinkedListAdapter.h"
-#include "../timemanager/CCSDSTime.h"
+#include "fsfw/datapool/LocalPoolObjectBase.h"
+#include "fsfw/datapool/SharedSetBase.h"
+#include "fsfw/serialize/SerialBufferAdapter.h"
+#include "fsfw/serialize/SerialLinkedListAdapter.h"
+#include "fsfw/timemanager/CCSDSTime.h"
 
 /**
  * @brief   This helper class will be used to serialize and deserialize update housekeeping packets
@@ -20,7 +19,7 @@ class HousekeepingSnapshot : public SerializeIF {
    * @param dataSetPtr        Pointer to the dataset instance to serialize or deserialize the
    *                          data into
    */
-  HousekeepingSnapshot(CCSDSTime::CDS_short* cdsShort, LocalPoolDataSetBase* dataSetPtr)
+  HousekeepingSnapshot(CCSDSTime::CDS_short* cdsShort, SerializeIF* dataSetPtr)
       : timeStamp(reinterpret_cast<uint8_t*>(cdsShort)),
         timeStampSize(sizeof(CCSDSTime::CDS_short)),
         updateData(dataSetPtr) {};
@@ -31,27 +30,7 @@ class HousekeepingSnapshot : public SerializeIF {
    * @param timeStampSize     Size of the timestamp
    * @param dataSetPtr        Pointer to the dataset instance to deserialize the data into
    */
-  HousekeepingSnapshot(uint8_t* timeStamp, size_t timeStampSize, LocalPoolDataSetBase* dataSetPtr)
-      : timeStamp(timeStamp), timeStampSize(timeStampSize), updateData(dataSetPtr) {};
-
-  /**
-   * Update packet constructor for pool variables.
-   * @param timeStamp
-   * @param timeStampSize
-   * @param dataSetPtr
-   */
-  HousekeepingSnapshot(CCSDSTime::CDS_short* cdsShort, LocalPoolObjectBase* dataSetPtr)
-      : timeStamp(reinterpret_cast<uint8_t*>(cdsShort)),
-        timeStampSize(sizeof(CCSDSTime::CDS_short)),
-        updateData(dataSetPtr) {};
-
-  /**
-   * Update packet constructor for pool variables.
-   * @param timeStamp
-   * @param timeStampSize
-   * @param dataSetPtr
-   */
-  HousekeepingSnapshot(uint8_t* timeStamp, size_t timeStampSize, LocalPoolObjectBase* dataSetPtr)
+  HousekeepingSnapshot(uint8_t* timeStamp, size_t timeStampSize, SerializeIF* dataSetPtr)
       : timeStamp(timeStamp), timeStampSize(timeStampSize), updateData(dataSetPtr) {};
 
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
@@ -106,6 +85,4 @@ class HousekeepingSnapshot : public SerializeIF {
   size_t timeStampSize = 0;
 
   SerializeIF* updateData = nullptr;
-};
-
-#endif /* FSFW_HOUSEKEEPING_HOUSEKEEPINGSNAPSHOT_H_ */
+};
\ No newline at end of file
diff --git a/src/fsfw/housekeeping/PeriodicHkHelper.cpp b/src/fsfw/housekeeping/PeriodicHkHelper.cpp
new file mode 100644
index 00000000..3949045d
--- /dev/null
+++ b/src/fsfw/housekeeping/PeriodicHkHelper.cpp
@@ -0,0 +1,407 @@
+#include "PeriodicHkHelper.h"
+
+#include <cmath>
+#include <functional>
+#include <set>
+
+#include "fsfw/housekeeping/AcceptsHkPacketsIF.h"
+#include "fsfw/housekeeping/HousekeepingSetPacket.h"
+#include "fsfw/housekeeping/HousekeepingSnapshot.h"
+#include "fsfw/ipc/QueueFactory.h"
+#include "fsfw/objectmanager/ObjectManager.h"
+#include "fsfw/timemanager/CCSDSTime.h"
+
+using namespace hk;
+
+PeriodicHelper::PeriodicHelper(GeneratesPeriodicHkIF* owner, MessageQueueIF* queueToUse,
+                               MessageQueueId_t hkDestQueue)
+    : hkDestinationId(hkDestQueue) {
+  if (owner == nullptr) {
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "LocalDataPoolManager", returnvalue::FAILED,
+                        "Invalid supplied owner");
+    return;
+  }
+  this->owner = owner;
+  hkQueue = queueToUse;
+}
+
+ReturnValue_t PeriodicHelper::initialize(MessageQueueIF* queueToUse) {
+  if (queueToUse != nullptr) {
+    hkQueue = queueToUse;
+  }
+  if (hkQueue == nullptr) {
+    // Error, all destinations invalid
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", QUEUE_OR_DESTINATION_INVALID);
+  }
+
+  ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
+  if (ipcStore == nullptr) {
+    // Error, all destinations invalid
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", returnvalue::FAILED,
+                        "Could not set IPC store.");
+    return returnvalue::FAILED;
+  }
+
+  if (hkDestinationId == MessageQueueIF::NO_QUEUE) {
+    if (const auto* hkPacketReceiver =
+            ObjectManager::instance()->get<AcceptsHkPacketsIF>(objects::PUS_SERVICE_3_HOUSEKEEPING);
+        hkPacketReceiver != nullptr) {
+      hkDestinationId = hkPacketReceiver->getHkQueue();
+    } else {
+      printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize", QUEUE_OR_DESTINATION_INVALID);
+      return QUEUE_OR_DESTINATION_INVALID;
+    }
+  }
+
+  owner->specifyHkDatasets(setList);
+
+  return returnvalue::OK;
+}
+
+ReturnValue_t PeriodicHelper::performHkOperation() {
+  timeval now{};
+  Clock::getClockMonotonic(&now);
+  for (auto& setSpec : setList) {
+    switch (setSpec.reportingType) {
+      case (ReportingType::PERIODIC): {
+        if (setSpec.dataType == DataType::LOCAL_POOL_VARIABLE) {
+          // Periodic packets shall only be generated from datasets
+          continue;
+        }
+        if (not setSpec.periodicCollectionEnabled) {
+          continue;
+        }
+        performPeriodicHkGeneration(setSpec, now);
+        break;
+      }
+      default:
+        // This should never happen.
+        return returnvalue::FAILED;
+    }
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t PeriodicHelper::handleHousekeepingMessage(CommandMessage* message) {
+  Command_t command = message->getCommand();
+  dp::sid_t sid = HousekeepingMessage::getStructureId(message);
+  ReturnValue_t result = returnvalue::OK;
+  switch (command) {
+    // Houskeeping interface handling.
+    case (HousekeepingMessage::ENABLE_PERIODIC_HK_REPORT_GENERATION): {
+      result = togglePeriodicGeneration(sid, true);
+      break;
+    }
+
+    case (HousekeepingMessage::DISABLE_PERIODIC_HK_REPORT_GENERATION): {
+      result = togglePeriodicGeneration(sid, false);
+      break;
+    }
+
+    case (HousekeepingMessage::REPORT_HK_REPORT_STRUCTURES): {
+      result = generateSetStructurePacket(sid);
+      if (result == returnvalue::OK) {
+        return result;
+      }
+      break;
+    }
+    case (HousekeepingMessage::MODIFY_PARAMETER_REPORT_COLLECTION_INTERVAL): {
+      dur_millis_t newCollIntvl = 0;
+      HousekeepingMessage::getCollectionIntervalModificationCommand(message, newCollIntvl);
+      result = setCollectionInterval(sid, newCollIntvl);
+      break;
+    }
+
+    case (HousekeepingMessage::GENERATE_ONE_PARAMETER_REPORT): {
+      return generateHousekeepingPacket(HousekeepingMessage::getStructureId(message));
+    }
+
+    default:
+      return CommandMessageIF::UNKNOWN_COMMAND;
+  }
+
+  CommandMessage reply;
+  if (result != returnvalue::OK) {
+    if (result == INVALID_HK_REQUEST) {
+      printWarningOrError(sif::OutputTypes::OUT_WARNING, "handleHousekeepingMessage",
+                          INVALID_HK_REQUEST);
+    }
+    HousekeepingMessage::setHkRequestFailureReply(&reply, sid, result);
+  } else {
+    HousekeepingMessage::setHkRequestSuccessReply(&reply, sid);
+  }
+  hkQueue->sendMessage(hkDestinationId, &reply);
+  return result;
+}
+
+GeneratesPeriodicHkIF* PeriodicHelper::getOwner() const { return owner; }
+
+ReturnValue_t PeriodicHelper::generateHousekeepingPacket(const dp::sid_t sid,
+                                                         MessageQueueId_t destination) {
+  store_address_t storeId;
+  const auto optSetSpec = getMutSetSpecification(sid);
+  if (!optSetSpec.has_value()) {
+    return DATASET_NOT_FOUND;
+  }
+  const auto& setSpec = optSetSpec.value().get();
+  uint8_t* dataPtr = nullptr;
+  const size_t maxSize = setSpec.serializedSize + dp::structure_id_t::SIZE;
+  ReturnValue_t result = ipcStore->getFreeElement(&storeId, maxSize, &dataPtr);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  size_t serSize = 0;
+  result = SerializeAdapter::serialize(&sid.objectId, &dataPtr, &serSize, maxSize,
+                                       SerializeIF::Endianness::NETWORK);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::serialize(&sid.ownerSetId, &dataPtr, &serSize, maxSize,
+                                       SerializeIF::Endianness::NETWORK);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = owner->serializeHkDataset(sid, dataPtr, maxSize - 8);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  // Now we set a HK message and send it the HK packet destination.
+  CommandMessage hkMessage;
+  HousekeepingMessage::setHkReportReply(&hkMessage, sid, storeId);
+
+  if (hkQueue == nullptr) {
+    // Error, no queue available to send packet with.
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket",
+                        QUEUE_OR_DESTINATION_INVALID);
+    return QUEUE_OR_DESTINATION_INVALID;
+  }
+  if (destination == MessageQueueIF::NO_QUEUE) {
+    if (hkDestinationId == MessageQueueIF::NO_QUEUE) {
+      // Error, all destinations invalid
+      printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateHousekeepingPacket",
+                          QUEUE_OR_DESTINATION_INVALID);
+      return QUEUE_OR_DESTINATION_INVALID;
+    }
+    destination = hkDestinationId;
+  }
+
+  return hkQueue->sendMessage(destination, &hkMessage);
+}
+
+void PeriodicHelper::performPeriodicHkGeneration(SetSpecification& setSpec, timeval& now) {
+  const dp::sid_t sid = setSpec.dataId.sid;
+
+  auto [tv_sec, tv_usec] = now - setSpec.lastGenerated;
+  if (const dur_millis_t diffMillis = tv_sec * 1000 + tv_usec / 1000;
+      diffMillis >= setSpec.collectionFrequency) {
+    const ReturnValue_t result = generateHousekeepingPacket(sid);
+    setSpec.lastGenerated = now;
+    if (result != returnvalue::OK) {
+      // Configuration error
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::warning << "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed."
+                   << std::endl;
+#else
+      sif::printWarning(
+          "LocalDataPoolManager::performPeriodicHkOperation: HK generation failed.\n");
+#endif
+      return;
+    }
+  }
+}
+
+ReturnValue_t PeriodicHelper::togglePeriodicGeneration(const dp::sid_t sid, const bool enable) {
+  const auto optSetSpec = getMutSetSpecification(sid);
+  if (!optSetSpec.has_value()) {
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "togglePeriodicGeneration",
+                        DATASET_NOT_FOUND);
+    return DATASET_NOT_FOUND;
+  }
+  optSetSpec.value().get().periodicCollectionEnabled = enable;
+  return returnvalue::OK;
+}
+
+std::optional<std::reference_wrapper<SetSpecification>> PeriodicHelper::getMutSetSpecification(
+    dp::sid_t structureId) {
+  for (auto& receiver : setList) {
+    if (receiver.dataId.sid == structureId) {
+      return receiver;
+    }
+  }
+  return std::nullopt;
+}
+
+std::optional<std::reference_wrapper<const SetSpecification>> PeriodicHelper::getSetSpecification(
+    dp::sid_t structureId) const {
+  for (const auto& receiver : setList) {
+    if (receiver.dataId.sid == structureId) {
+      return receiver;
+    }
+  }
+  return std::nullopt;
+}
+
+ReturnValue_t PeriodicHelper::setCollectionInterval(dp::sid_t sid,
+                                                    dur_millis_t newCollectionIntervalMs) {
+  bool wasUpdated = false;
+  for (auto& receiver : setList) {
+    if (receiver.dataId.sid == sid) {
+      receiver.collectionFrequency = newCollectionIntervalMs;
+      wasUpdated = true;
+    }
+  }
+  if (!wasUpdated) {
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "setCollectionInterval", DATASET_NOT_FOUND);
+    return DATASET_NOT_FOUND;
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t PeriodicHelper::generateSetStructurePacket(dp::structure_id_t sid) {
+  // Get and check dataset first.
+  auto optSetSpec = getMutSetSpecification(sid);
+  if (!optSetSpec.has_value()) {
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "performPeriodicHkGeneration",
+                        DATASET_NOT_FOUND);
+    return DATASET_NOT_FOUND;
+  }
+  auto& setSpec = optSetSpec.value().get();
+
+  uint8_t* storePtr = nullptr;
+  store_address_t storeId;
+  ReturnValue_t result = ipcStore->getFreeElement(&storeId, setSpec.serializedSize, &storePtr);
+  if (result != returnvalue::OK) {
+    printWarningOrError(sif::OutputTypes::OUT_ERROR, "generateSetStructurePacket",
+                        returnvalue::FAILED, "Could not get free element from IPC store.");
+    return result;
+  }
+
+  dur_millis_t collectionInterval = 0;
+
+  HousekeepingSetPacket setPacket(sid, setSpec.periodicCollectionEnabled, collectionInterval);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  size_t expectedSize = setPacket.getSerializedSize();
+
+  // Serialize set packet into store.
+  size_t size = 0;
+  result = setPacket.serialize(&storePtr, &size, expectedSize, SerializeIF::Endianness::NETWORK);
+  if (result != returnvalue::OK) {
+    ipcStore->deleteData(storeId);
+    return result;
+  }
+  if (expectedSize != size) {
+    printWarningOrError(sif::OutputTypes::OUT_WARNING, "generateSetStructurePacket",
+                        returnvalue::FAILED, "Expected size is not equal to serialized size");
+  }
+
+  // Send structure reporting reply.
+  CommandMessage reply;
+  HousekeepingMessage::setHkStuctureReportReply(&reply, sid, storeId);
+
+  result = hkQueue->reply(&reply);
+  if (result != returnvalue::OK) {
+    ipcStore->deleteData(storeId);
+  }
+  return result;
+}
+
+ReturnValue_t PeriodicHelper::enablePeriodicPacket(const dp::structure_id_t structureId,
+                                                   const std::optional<dur_millis_t> frequencyMs) {
+  // Get and check dataset first.
+  const auto optSetSpec = getMutSetSpecification(structureId);
+  if (!optSetSpec.has_value()) {
+    return DATASET_NOT_FOUND;
+  }
+  auto& setSpec = optSetSpec.value().get();
+  setSpec.periodicCollectionEnabled = true;
+  if (frequencyMs) {
+    setSpec.collectionFrequency = frequencyMs.value();
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t PeriodicHelper::disablePeriodicPacket(const dp::structure_id_t structureId) {
+  // Get and check dataset first.
+  const auto optSetSpec = getMutSetSpecification(structureId);
+  if (!optSetSpec.has_value()) {
+    return DATASET_NOT_FOUND;
+  }
+  auto& setSpec = optSetSpec.value().get();
+  setSpec.periodicCollectionEnabled = false;
+  return returnvalue::OK;
+}
+
+ReturnValue_t PeriodicHelper::collectionEnabled(dp::sid_t structureId,
+                                                bool& collectionEnabled) const {
+  // Get and check dataset first.
+  const auto optSetSpec = getSetSpecification(structureId);
+  if (!optSetSpec.has_value()) {
+    return DATASET_NOT_FOUND;
+  }
+  auto& setSpec = optSetSpec.value().get();
+  collectionEnabled = setSpec.periodicCollectionEnabled;
+  return returnvalue::OK;
+}
+object_id_t PeriodicHelper::getCreatorObjectId() const { return owner->getObjectId(); }
+
+void PeriodicHelper::printWarningOrError(sif::OutputTypes outputType, const char* functionName,
+                                         ReturnValue_t error, const char* errorPrint) {
+#if FSFW_VERBOSE_LEVEL >= 1
+  if (errorPrint == nullptr) {
+    if (error == DATASET_NOT_FOUND) {
+      errorPrint = "Dataset not found";
+    } else if (error == INVALID_HK_REQUEST) {
+      errorPrint = "Invalid HK request";
+    } else if (error == returnvalue::FAILED) {
+      if (outputType == sif::OutputTypes::OUT_WARNING) {
+        errorPrint = "Generic Warning";
+      } else {
+        errorPrint = "Generic error";
+      }
+    } else if (error == QUEUE_OR_DESTINATION_INVALID) {
+      errorPrint = "Queue or destination not set";
+    } else if (error == dp::POOL_ENTRY_TYPE_CONFLICT) {
+      errorPrint = "Pool entry type conflict";
+    } else if (error == dp::POOL_ENTRY_NOT_FOUND) {
+      errorPrint = "Pool entry not found";
+    } else {
+      errorPrint = "Unknown error";
+    }
+  }
+  object_id_t objectId = 0xffffffff;
+  if (owner != nullptr) {
+    objectId = owner->getObjectId();
+  }
+
+  if (outputType == sif::OutputTypes::OUT_WARNING) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "LocalDataPoolManager::" << functionName << ": Object ID 0x" << std::setw(8)
+                 << std::setfill('0') << std::hex << objectId << " | " << errorPrint << std::dec
+                 << std::setfill(' ') << std::endl;
+#else
+    sif::printWarning("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n", functionName, objectId,
+                      errorPrint);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+  } else if (outputType == sif::OutputTypes::OUT_ERROR) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "LocalDataPoolManager::" << functionName << ": Object ID 0x" << std::setw(8)
+               << std::setfill('0') << std::hex << objectId << " | " << errorPrint << std::dec
+               << std::setfill(' ') << std::endl;
+#else
+    sif::printError("LocalDataPoolManager::%s: Object ID 0x%08x | %s\n", functionName, objectId,
+                    errorPrint);
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+  }
+#endif /* #if FSFW_VERBOSE_LEVEL >= 1 */
+}
+
+void PeriodicHelper::setHkDestinationId(const MessageQueueId_t hkDestId) {
+  hkDestinationId = hkDestId;
+}
+
+void PeriodicHelper::addSetSpecification(const SetSpecification& setSpec) {
+  setList.push_back(setSpec);
+}
diff --git a/src/fsfw/housekeeping/PeriodicHkHelper.h b/src/fsfw/housekeeping/PeriodicHkHelper.h
new file mode 100644
index 00000000..92d72944
--- /dev/null
+++ b/src/fsfw/housekeeping/PeriodicHkHelper.h
@@ -0,0 +1,192 @@
+#pragma once
+
+#include <map>
+#include <optional>
+#include <vector>
+
+#include "GeneratesPeriodicHkIF.h"
+#include "PeriodicHkHelperIF.h"
+#include "definitions.h"
+#include "fsfw/datapool/DataSetIF.h"
+#include "fsfw/datapool/definitions.h"
+#include "fsfw/housekeeping/HousekeepingMessage.h"
+#include "fsfw/housekeeping/HousekeepingPacketDownlink.h"
+#include "fsfw/ipc/CommandMessage.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/ipc/MutexIF.h"
+#include "fsfw/objectmanager/SystemObjectIF.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+
+namespace hk {
+
+/**
+ * @brief 		This class is the managing instance for the local data pool.
+ * @details
+ * The actual data pool structure is a member of this class. Any class which
+ * has a local data pool shall have this manager class as a member and implement
+ * the HasLocalDataPoolIF.
+ *
+ * The manager offers some adaption points and functions which can be used
+ * by the owning class to simplify data handling significantly.
+ *
+ * Please ensure that both initialize and initializeAfterTaskCreation are
+ * called at some point by the owning class in the respective functions of the
+ * same name!
+ *
+ * Users of the data pool use the helper classes LocalDataSet,
+ * LocalPoolVariable and LocalPoolVector to access pool entries in
+ * a thread-safe and efficient way.
+ *
+ * The local data pools employ a blackboard logic: Only the most recent
+ * value is stored. The helper classes offer a read() and commit() interface
+ * through the PoolVariableIF which is used to read and update values.
+ * Each pool entry has a valid state too.
+ * @author 		R. Mueller
+ */
+class PeriodicHelper : public PeriodicHelperIF {
+  //! Some classes using the pool manager directly need to access class internals of the
+  //! manager. The attorney provides granular control of access to these internals.
+  friend class SharedPoolAttorney;
+
+ public:
+  /**
+   * This constructor is used by a class which wants to implement
+   * a personal local data pool. The queueToUse can be supplied if it
+   * is already known.
+   *
+   * initialize() has to be called in any case before using the object!
+   * @param owner
+   * @param queueToUse
+   * validity state is generated  when serializing or deserializing packets.
+   */
+  PeriodicHelper(GeneratesPeriodicHkIF* owner, MessageQueueIF* queueToUse,
+                 MessageQueueId_t hkDestQueue = MessageQueueIF::NO_QUEUE);
+
+  void setHkDestinationId(MessageQueueId_t hkDestId);
+
+  /**
+   * Assigns the queue to use. Make sure to call this in the #initialize
+   * function of the owner.
+   * @param queueToUse
+   */
+  ReturnValue_t initialize(MessageQueueIF* queueToUse);
+
+  /**
+   * @brief   This should be called in the periodic handler of the owner.
+   * @details
+   * This in generally called in the #performOperation function of the owner.
+   * It performs all the periodic functionalities of the data pool manager,
+   * for example generating periodic HK packets.
+   * Marked virtual as an adaption point for custom data pool managers.
+   * @return
+   */
+  virtual ReturnValue_t performHkOperation();
+
+  /**
+   * @brief   The manager is also able to handle housekeeping messages.
+   * @details
+   * This most commonly is used to handle messages for the housekeeping
+   * interface, but the manager is also able to handle update notifications
+   * and calls a special function which can be overriden by a child class
+   * to handle data set or pool variable updates. This is relevant
+   * for classes like controllers which have their own local datapool
+   * but pull their data from other local datapools.
+   * @param message
+   * @return
+   */
+  virtual ReturnValue_t handleHousekeepingMessage(CommandMessage* message);
+
+  /**
+   * Generate a housekeeping packet with a given SID.
+   * @param sid
+   * @return
+   */
+  ReturnValue_t generateHousekeepingPacket(dp::sid_t sid,
+                                           MessageQueueId_t destination = MessageQueueIF::NO_QUEUE);
+
+  [[nodiscard]] GeneratesPeriodicHkIF* getOwner() const;
+
+  void addSetSpecification(const SetSpecification& setSpec);
+  ReturnValue_t printPoolEntry(dp::id_t localPoolId);
+
+  /* Copying forbidden */
+  PeriodicHelper(const PeriodicHkGenerationHelper&) = delete;
+  PeriodicHelper operator=(const PeriodicHkGenerationHelper&) = delete;
+
+  /**
+   * This function can be used to clear the receivers list. This is
+   * intended for test functions and not for regular operations, because
+   * the insertion operations allocate dynamically.
+   */
+  // void clearReceiversList();
+
+  [[nodiscard]] object_id_t getCreatorObjectId() const;
+
+  /**
+   * Get the pointer to the mutex. Can be used to lock the data pool
+   * externally. Use with care and don't forget to unlock locked mutexes!
+   * For now, only friend classes can accss this function.
+   * @return
+   */
+  MutexIF* getMutexHandle();
+
+  /**
+   * Set the periodic generation frequency without enabling the periodic generation of packets.
+   */
+  ReturnValue_t enablePeriodicPacket(dp::sid_t structureId,
+                                     std::optional<dur_millis_t> frequencyMs) override;
+  ReturnValue_t disablePeriodicPacket(dp::sid_t structureId) override;
+  ReturnValue_t collectionEnabled(dp::sid_t structureId, bool& collectionEnabled) const override;
+
+  ReturnValue_t setCollectionInterval(dp::sid_t structureId,
+                                      dur_millis_t newCollectionIntervalMs) override;
+
+  std::optional<std::reference_wrapper<SetSpecification>> getMutSetSpecification(
+      dp::sid_t structureId);
+
+  std::optional<std::reference_wrapper<const SetSpecification>> getSetSpecification(
+      dp::sid_t structureId) const;
+
+ protected:
+  std::optional<dur_millis_t> getCollectionFrequency(dp::sid_t structureId);
+
+  /** The class which actually owns the manager (and its datapool). */
+  hk::GeneratesPeriodicHkIF* owner = nullptr;
+
+  /** Default receiver for periodic HK packets */
+  MessageQueueId_t hkDestinationId = MessageQueueIF::NO_QUEUE;
+
+  /** This vector will contain the list of HK receivers. */
+  using SetList = std::vector<SetSpecification>;
+
+  SetList setList{};
+
+  /**
+   * @brief Queue used for communication, for example commands.
+   * Is also used to send messages. Can be set either in the constructor
+   * or in the initialize() function.
+   */
+  MessageQueueIF* hkQueue = nullptr;
+
+  /** Global IPC store is used to store all packets. */
+  StorageManagerIF* ipcStore = nullptr;
+
+  ReturnValue_t serializeHkPacketIntoStore(HousekeepingPacketDownlink& hkPacket,
+                                           store_address_t& storeId, size_t* serializedSize);
+
+  void performPeriodicHkGeneration(SetSpecification& hkReceiver, timeval& now);
+  ReturnValue_t togglePeriodicGeneration(dp::sid_t sid, bool enable);
+  ReturnValue_t generateSetStructurePacket(dp::sid_t sid);
+
+  // void handleChangeResetLogic(periodicHk::DataType type, periodicHk::DataId dataId,
+  // MarkChangedIF* toReset);
+  // void resetHkUpdateResetHelper();
+
+  // ReturnValue_t addUpdateToStore(HousekeepingSnapshot& updatePacket, store_address_t& storeId);
+
+  void printWarningOrError(sif::OutputTypes outputType, const char* functionName,
+                           ReturnValue_t errorCode = returnvalue::FAILED,
+                           const char* errorPrint = nullptr);
+};
+
+}  // namespace hk
\ No newline at end of file
diff --git a/src/fsfw/housekeeping/PeriodicHkHelperIF.h b/src/fsfw/housekeeping/PeriodicHkHelperIF.h
new file mode 100644
index 00000000..29bd81c3
--- /dev/null
+++ b/src/fsfw/housekeeping/PeriodicHkHelperIF.h
@@ -0,0 +1,24 @@
+#pragma once
+
+#include <fsfw/timemanager/clockDefinitions.h>
+
+#include "fsfw/datapool/definitions.h"
+#include "fsfw/retval.h"
+
+namespace hk {
+class PeriodicHelperIF {
+ public:
+  virtual ~PeriodicHelperIF() = default;
+
+  /**
+   * Set the periodic generation frequency without enabling the periodic generation of packets.
+   */
+  virtual ReturnValue_t setCollectionInterval(dp::sid_t structureId,
+                                              dur_millis_t newCollectionIntervalMs) = 0;
+  virtual ReturnValue_t enablePeriodicPacket(dp::sid_t structureId,
+                                             std::optional<dur_millis_t> frequencyMs) = 0;
+  virtual ReturnValue_t disablePeriodicPacket(dp::sid_t structureId) = 0;
+  virtual ReturnValue_t collectionEnabled(dp::sid_t structureId, bool& collectionEnabled) const = 0;
+};
+
+}  // namespace hk
\ No newline at end of file
diff --git a/src/fsfw/housekeeping/PeriodicHousekeepingHelper.cpp b/src/fsfw/housekeeping/PeriodicHousekeepingHelper.cpp
deleted file mode 100644
index ec34330a..00000000
--- a/src/fsfw/housekeeping/PeriodicHousekeepingHelper.cpp
+++ /dev/null
@@ -1,39 +0,0 @@
-#include "fsfw/housekeeping/PeriodicHousekeepingHelper.h"
-
-#include <cmath>
-
-#include "fsfw/datapoollocal/LocalPoolDataSetBase.h"
-#include "fsfw/serviceinterface.h"
-
-PeriodicHousekeepingHelper::PeriodicHousekeepingHelper(LocalPoolDataSetBase* owner)
-    : owner(owner) {}
-
-void PeriodicHousekeepingHelper::initialize(float collectionInterval,
-                                            dur_millis_t minimumPeriodicInterval) {
-  this->minimumPeriodicInterval = minimumPeriodicInterval;
-  changeCollectionInterval(collectionInterval);
-}
-
-float PeriodicHousekeepingHelper::getCollectionIntervalInSeconds() const {
-  return collectionInterval;
-}
-
-bool PeriodicHousekeepingHelper::checkOpNecessary() {
-  if (hkGenerationCd.hasTimedOut()) {
-    hkGenerationCd.resetTimer();
-    return true;
-  }
-  return false;
-}
-
-void PeriodicHousekeepingHelper::changeCollectionInterval(float newIntervalSeconds) {
-  uint32_t intervalMs = newIntervalSeconds * 1000;
-  if (newIntervalSeconds <= 0) {
-    intervalMs = minimumPeriodicInterval;
-    newIntervalSeconds = static_cast<float>(minimumPeriodicInterval) / 1000.0;
-  }
-  collectionInterval = newIntervalSeconds;
-  hkGenerationCd.setTimeout(intervalMs);
-  // We want an immediate HK packet at the start, so time out the generation CD immediately.
-  hkGenerationCd.timeOut();
-}
diff --git a/src/fsfw/housekeeping/PeriodicHousekeepingHelper.h b/src/fsfw/housekeeping/PeriodicHousekeepingHelper.h
deleted file mode 100644
index 1586649c..00000000
--- a/src/fsfw/housekeeping/PeriodicHousekeepingHelper.h
+++ /dev/null
@@ -1,29 +0,0 @@
-#ifndef FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_
-#define FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_
-
-#include <cstdint>
-
-#include "fsfw/timemanager/Clock.h"
-#include "fsfw/timemanager/Countdown.h"
-
-class LocalPoolDataSetBase;
-
-class PeriodicHousekeepingHelper {
- public:
-  PeriodicHousekeepingHelper(LocalPoolDataSetBase* owner);
-
-  void initialize(float collectionInterval, dur_millis_t minimumPeriodicInterval);
-
-  void changeCollectionInterval(float newInterval);
-  float getCollectionIntervalInSeconds() const;
-  bool checkOpNecessary();
-
- private:
-  LocalPoolDataSetBase* owner = nullptr;
-  Countdown hkGenerationCd;
-  float collectionInterval = 0.0;
-
-  dur_millis_t minimumPeriodicInterval = 0;
-};
-
-#endif /* FSFW_HOUSEKEEPING_PERIODICHOUSEKEEPINGHELPER_H_ */
diff --git a/src/fsfw/housekeeping/definitions.h b/src/fsfw/housekeeping/definitions.h
new file mode 100644
index 00000000..98b68e06
--- /dev/null
+++ b/src/fsfw/housekeeping/definitions.h
@@ -0,0 +1,86 @@
+#pragma once
+
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/ipc/messageQueueDefinitions.h>
+#include <fsfw/timemanager/clockDefinitions.h>
+
+#include <cstdint>
+#include <ctime>
+
+#include "fsfw/datapool/definitions.h"
+
+namespace hk {
+
+static constexpr uint8_t INTERFACE_ID = CLASS_ID::PERIODIC_HK_IF;
+
+static constexpr ReturnValue_t DATASET_NOT_FOUND = MAKE_RETURN_CODE(0);
+static constexpr ReturnValue_t QUEUE_OR_DESTINATION_INVALID = MAKE_RETURN_CODE(1);
+static constexpr ReturnValue_t INVALID_HK_REQUEST = MAKE_RETURN_CODE(2);
+
+/**
+ * Different types of housekeeping reporting are possible.
+ *  1. PERIODIC:
+ *     HK packets are generated in fixed intervals and sent to
+ *     destination. Fromat will be raw.
+ *  2. UPDATE_NOTIFICATION:
+ *     Notification will be sent out if HK data has changed.
+ *  3. UPDATE_SNAPSHOT:
+ *     HK packets are only generated if explicitely requested.
+ *     Propably not necessary, just use multiple local data sets or
+ *     shared datasets.
+ */
+enum class ReportingType : uint8_t {
+  //! Periodic generation of HK packets.
+  PERIODIC,
+};
+
+union DataId {
+  DataId() : sid() {}
+  static DataId forSetId(dp::structure_id_t sid) {
+    DataId d;
+    d.sid = sid;
+    return d;
+  }
+  dp::sid_t sid;
+  dp::id_t localPoolId;
+};
+
+/** Different data types are possible in the HK receiver map. For example, updates can be
+requested for full datasets or for single pool variables. Periodic reporting is only possible
+for data sets. */
+enum class DataType : uint8_t { LOCAL_POOL_VARIABLE, DATA_SET };
+
+struct SetSpecification {
+  friend class PeriodicHelper;
+
+ public:
+  SetSpecification(const dp::structure_id_t structureId, const size_t serializedSize,
+                   const dur_millis_t collectionFrequency,
+                   const MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE)
+      : dataId(DataId::forSetId(structureId)),
+        destinationQueue(destinationQueue),
+        serializedSize(serializedSize),
+        collectionFrequency(collectionFrequency) {};
+  // Object ID of receiver
+  object_id_t objectId = objects::NO_OBJECT;
+
+  DataType dataType = DataType::DATA_SET;
+  DataId dataId;
+
+  ReportingType reportingType = ReportingType::PERIODIC;
+
+  [[nodiscard]] size_t getSerializedSize() const { return serializedSize; }
+
+  [[nodiscard]] dur_millis_t getCollectionFrequency() const { return collectionFrequency; }
+
+  [[nodiscard]] bool collectionEnabled() const { return periodicCollectionEnabled; }
+
+ private:
+  MessageQueueId_t destinationQueue = MessageQueueIF::NO_QUEUE;
+  bool periodicCollectionEnabled = false;
+  size_t serializedSize = 0;
+  dur_millis_t collectionFrequency = 0;
+  timeval lastGenerated{};
+};
+
+}  // namespace hk
diff --git a/src/fsfw/internalerror/InternalErrorDataset.h b/src/fsfw/internalerror/InternalErrorDataset.h
index 022cdedb..41347917 100644
--- a/src/fsfw/internalerror/InternalErrorDataset.h
+++ b/src/fsfw/internalerror/InternalErrorDataset.h
@@ -1,22 +1,24 @@
 #ifndef FSFW_INTERNALERROR_INTERNALERRORDATASET_H_
 #define FSFW_INTERNALERROR_INTERNALERRORDATASET_H_
 
-#include <fsfw/datapoollocal/LocalPoolVariable.h>
-#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/datapool/PoolVariable.h>
+#include <fsfw/datapool/StaticSharedSet.h>
 
-enum errorPoolIds { TM_HITS, QUEUE_HITS, STORE_HITS };
+enum errorPoolIds { TM_HITS = 0, QUEUE_HITS = 1, STORE_HITS = 2, VALID = 3 };
 
-class InternalErrorDataset : public StaticLocalDataSet<3 * sizeof(uint32_t)> {
+class InternalErrorDataset : public dp::StaticSharedSet<4> {
  public:
   static constexpr uint8_t ERROR_SET_ID = 0;
 
-  InternalErrorDataset(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, ERROR_SET_ID) {}
+  InternalErrorDataset(dp::SharedPool& sharedPool) : StaticSharedSet(sharedPool, ERROR_SET_ID) {}
 
-  InternalErrorDataset(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, ERROR_SET_ID)) {}
+  InternalErrorDataset(object_id_t objectId)
+      : StaticSharedSet(dp::structure_id_t(objectId, ERROR_SET_ID)) {}
 
-  lp_var_t<uint32_t> tmHits = lp_var_t<uint32_t>(sid.objectId, TM_HITS, this);
-  lp_var_t<uint32_t> queueHits = lp_var_t<uint32_t>(sid.objectId, QUEUE_HITS, this);
-  lp_var_t<uint32_t> storeHits = lp_var_t<uint32_t>(sid.objectId, STORE_HITS, this);
+  dp::var_t<uint32_t> tmHits = dp::var_t<uint32_t>(sid.objectId, TM_HITS, this);
+  dp::var_t<uint32_t> queueHits = dp::var_t<uint32_t>(sid.objectId, QUEUE_HITS, this);
+  dp::var_t<uint32_t> storeHits = dp::var_t<uint32_t>(sid.objectId, STORE_HITS, this);
+  dp::var_t<uint8_t> valid = dp::var_t<uint8_t>(sid.objectId, VALID, this);
 };
 
 #endif /* FSFW_INTERNALERROR_INTERNALERRORDATASET_H_ */
diff --git a/src/fsfw/internalerror/InternalErrorReporter.cpp b/src/fsfw/internalerror/InternalErrorReporter.cpp
index 44910801..f27ecb63 100644
--- a/src/fsfw/internalerror/InternalErrorReporter.cpp
+++ b/src/fsfw/internalerror/InternalErrorReporter.cpp
@@ -6,16 +6,18 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
 InternalErrorReporter::InternalErrorReporter(object_id_t setObjectId, uint32_t messageQueueDepth,
-                                             bool enableSetByDefault, float generationFrequency)
+                                             bool enableSetByDefault,
+                                             dur_millis_t generationFrequency)
     : SystemObject(setObjectId),
-      poolManager(this, commandQueue),
+      sharedPool(getObjectId()),
+      hkHelper(this, nullptr),
       enableSetByDefault(enableSetByDefault),
       generationFrequency(generationFrequency),
       internalErrorSid(setObjectId, InternalErrorDataset::ERROR_SET_ID),
-      internalErrorDataset(this) {
+      internalErrorDataset(sharedPool) {
   commandQueue = QueueFactory::instance()->createMessageQueue(messageQueueDepth);
   mutex = MutexFactory::instance()->createMutex();
-  auto mqArgs = MqArgs(setObjectId, static_cast<void *>(this));
+  auto mqArgs = MqArgs(setObjectId, this);
   commandQueue = QueueFactory::instance()->createMessageQueue(
       messageQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
@@ -29,11 +31,25 @@ void InternalErrorReporter::setDiagnosticPrintout(bool enable) {
   this->diagnosticPrintout = enable;
 }
 
+ReturnValue_t InternalErrorReporter::initialize() {
+  ReturnValue_t result = hkHelper.initialize(commandQueue);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  sharedPool.addPoolEntry(errorPoolIds::STORE_HITS, &storeHitsEntry);
+  sharedPool.addPoolEntry(errorPoolIds::TM_HITS, &tmHitsEntry);
+  sharedPool.addPoolEntry(errorPoolIds::QUEUE_HITS, &queueHitsEntry);
+  sharedPool.addPoolEntry(errorPoolIds::VALID, &setIsValid);
+  internalErrorDataset.valid = false;
+  return SystemObject::initialize();
+}
+
 ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
   CommandMessage message;
   ReturnValue_t result = commandQueue->receiveMessage(&message);
   if (result != MessageQueueIF::EMPTY) {
-    poolManager.handleHousekeepingMessage(&message);
+    hkHelper.handleHousekeepingMessage(&message);
   }
 
   uint32_t newQueueHits = getAndResetQueueHits();
@@ -64,14 +80,11 @@ ReturnValue_t InternalErrorReporter::performOperation(uint8_t opCode) {
       internalErrorDataset.queueHits.value += newQueueHits;
       internalErrorDataset.storeHits.value += newStoreHits;
       internalErrorDataset.tmHits.value += newTmHits;
-      internalErrorDataset.setValidity(true, true);
-      if ((newQueueHits != 0) or (newStoreHits != 0) or (newTmHits != 0)) {
-        internalErrorDataset.setChanged(true);
-      }
+      internalErrorDataset.valid = true;
     }
   }
 
-  poolManager.performHkOperation();
+  hkHelper.performHkOperation();
   return returnvalue::OK;
 }
 
@@ -132,42 +145,27 @@ MessageQueueId_t InternalErrorReporter::getCommandQueue() const {
   return this->commandQueue->getId();
 }
 
-ReturnValue_t InternalErrorReporter::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                                             LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(errorPoolIds::TM_HITS, &tmHitsEntry);
-  localDataPoolMap.emplace(errorPoolIds::QUEUE_HITS, &queueHitsEntry);
-  localDataPoolMap.emplace(errorPoolIds::STORE_HITS, &storeHitsEntry);
-  poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(internalErrorSid, enableSetByDefault, generationFrequency));
-  internalErrorDataset.setValidity(true, true);
-  return returnvalue::OK;
-}
-
-dur_millis_t InternalErrorReporter::getPeriodicOperationFrequency() const {
-  return this->executingTask->getPeriodMs();
-}
-
-LocalPoolDataSetBase *InternalErrorReporter::getDataSetHandle(sid_t sid) {
-  return &internalErrorDataset;
-}
-
 void InternalErrorReporter::setTaskIF(PeriodicTaskIF *task) { this->executingTask = task; }
 
-ReturnValue_t InternalErrorReporter::initialize() {
-  ReturnValue_t result = poolManager.initialize(commandQueue);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  return SystemObject::initialize();
-}
-
-ReturnValue_t InternalErrorReporter::initializeAfterTaskCreation() {
-  return poolManager.initializeAfterTaskCreation();
-}
-
 void InternalErrorReporter::setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs) {
   this->timeoutType = timeoutType;
   this->timeoutMs = timeoutMs;
 }
 
-LocalDataPoolManager *InternalErrorReporter::getHkManagerHandle() { return &poolManager; }
+ReturnValue_t InternalErrorReporter::serializeHkDataset(dp::structure_id_t structureId,
+                                                        uint8_t *buf, size_t maxSize) {
+  if (structureId == internalErrorDataset.getStructureId()) {
+    size_t serSize = 0;
+    return internalErrorDataset.serialize(buf, serSize, maxSize, SerializeIF::Endianness::NETWORK);
+  }
+  return returnvalue::FAILED;
+}
+
+ReturnValue_t InternalErrorReporter::specifyHkDatasets(
+    std::vector<hk::SetSpecification> &setSpecification) {
+  setSpecification.emplace_back(internalErrorDataset.getStructureId(),
+                                internalErrorDataset.getSerializedSize(), generationFrequency);
+  return returnvalue::OK;
+}
+
+dp::SharedPool *InternalErrorReporter::getOptionalSharedPool() { return &sharedPool; }
diff --git a/src/fsfw/internalerror/InternalErrorReporter.h b/src/fsfw/internalerror/InternalErrorReporter.h
index f845410b..c7704a15 100644
--- a/src/fsfw/internalerror/InternalErrorReporter.h
+++ b/src/fsfw/internalerror/InternalErrorReporter.h
@@ -1,8 +1,10 @@
 #ifndef FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_
 #define FSFW_INTERNALERROR_INTERNALERRORREPORTER_H_
 
+#include <fsfw/housekeeping/PeriodicHkHelper.h>
+
 #include "InternalErrorReporterIF.h"
-#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+#include "fsfw/housekeeping/GeneratesPeriodicHkIF.h"
 #include "fsfw/internalerror/InternalErrorDataset.h"
 #include "fsfw/ipc/MutexIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
@@ -19,10 +21,10 @@
 class InternalErrorReporter : public SystemObject,
                               public ExecutableObjectIF,
                               public InternalErrorReporterIF,
-                              public HasLocalDataPoolIF {
+                              public hk::GeneratesPeriodicHkIF {
  public:
   InternalErrorReporter(object_id_t setObjectId, uint32_t messageQueueDepth,
-                        bool enableSetByDefault, float generationFrequency);
+                        bool enableSetByDefault, dur_millis_t generationFrequency);
 
   /**
    * Enable diagnostic printout. Please note that this feature will
@@ -33,31 +35,32 @@ class InternalErrorReporter : public SystemObject,
 
   void setMutexTimeout(MutexIF::TimeoutType timeoutType, uint32_t timeoutMs);
 
-  virtual ~InternalErrorReporter();
+  ~InternalErrorReporter() override;
 
-  virtual object_id_t getObjectId() const override;
-  virtual MessageQueueId_t getCommandQueue() const override;
-  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                                LocalDataPoolManager& poolManager) override;
-  virtual dur_millis_t getPeriodicOperationFrequency() const override;
-  virtual LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
-  LocalDataPoolManager* getHkManagerHandle() override;
+  [[nodiscard]] object_id_t getObjectId() const override;
+  [[nodiscard]] MessageQueueId_t getCommandQueue() const override;
 
-  virtual ReturnValue_t initialize() override;
-  virtual ReturnValue_t initializeAfterTaskCreation() override;
-  virtual ReturnValue_t performOperation(uint8_t opCode) override;
+  dp::SharedPool* getOptionalSharedPool() override;
 
-  virtual void queueMessageNotSent() override;
+  ReturnValue_t serializeHkDataset(dp::sid_t structureId, uint8_t* buf, size_t maxSize) override;
 
-  virtual void lostTm() override;
+  ReturnValue_t specifyHkDatasets(std::vector<hk::SetSpecification>& setSpecification) override;
 
-  virtual void storeFull() override;
+  ReturnValue_t initialize() override;
+  ReturnValue_t performOperation(uint8_t opCode) override;
 
-  virtual void setTaskIF(PeriodicTaskIF* task) override;
+  void queueMessageNotSent() override;
+
+  void lostTm() override;
+
+  void storeFull() override;
+
+  void setTaskIF(PeriodicTaskIF* task) override;
 
  protected:
   MessageQueueIF* commandQueue;
-  LocalDataPoolManager poolManager;
+  dp::SharedPool sharedPool;
+  hk::PeriodicHelper hkHelper;
 
   PeriodicTaskIF* executingTask = nullptr;
 
@@ -65,9 +68,9 @@ class InternalErrorReporter : public SystemObject,
   MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
   uint32_t timeoutMs = 20;
   bool enableSetByDefault;
-  float generationFrequency;
+  dur_millis_t generationFrequency;
 
-  sid_t internalErrorSid;
+  dp::structure_id_t internalErrorSid;
   InternalErrorDataset internalErrorDataset;
 
   bool diagnosticPrintout = true;
@@ -75,6 +78,7 @@ class InternalErrorReporter : public SystemObject,
   uint32_t queueHits = 0;
   uint32_t tmHits = 0;
   uint32_t storeHits = 0;
+  PoolEntry<uint8_t> setIsValid = PoolEntry<uint8_t>();
   PoolEntry<uint32_t> tmHitsEntry = PoolEntry<uint32_t>();
   PoolEntry<uint32_t> storeHitsEntry = PoolEntry<uint32_t>();
   PoolEntry<uint32_t> queueHitsEntry = PoolEntry<uint32_t>();
diff --git a/src/fsfw/monitoring/AbsLimitMonitor.h b/src/fsfw/monitoring/AbsLimitMonitor.h
index 159a3d2a..b302f5a1 100644
--- a/src/fsfw/monitoring/AbsLimitMonitor.h
+++ b/src/fsfw/monitoring/AbsLimitMonitor.h
@@ -9,7 +9,7 @@
 template <typename T>
 class AbsLimitMonitor : public MonitorBase<T> {
  public:
-  AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId, gp_id_t globalPoolId,
+  AbsLimitMonitor(object_id_t reporterId, uint8_t monitorId, dp::g_id_t globalPoolId,
                   uint16_t confirmationLimit, T limit,
                   Event violationEvent = MonitoringIF::VALUE_OUT_OF_RANGE,
                   bool aboveIsViolation = true)
diff --git a/src/fsfw/monitoring/LimitMonitor.h b/src/fsfw/monitoring/LimitMonitor.h
index 4fe9ee39..325c2a78 100644
--- a/src/fsfw/monitoring/LimitMonitor.h
+++ b/src/fsfw/monitoring/LimitMonitor.h
@@ -13,7 +13,7 @@
 template <typename T>
 class LimitMonitor : public MonitorBase<T> {
  public:
-  LimitMonitor(object_id_t reporterId, uint8_t monitorId, gp_id_t globalPoolId,
+  LimitMonitor(object_id_t reporterId, uint8_t monitorId, dp::g_id_t globalPoolId,
                uint16_t confirmationLimit, T lowerLimit, T upperLimit,
                Event belowLowEvent = MonitoringIF::VALUE_BELOW_LOW_LIMIT,
                Event aboveHighEvent = MonitoringIF::VALUE_ABOVE_HIGH_LIMIT)
diff --git a/src/fsfw/monitoring/MonitorBase.h b/src/fsfw/monitoring/MonitorBase.h
index dd0792b2..b6404656 100644
--- a/src/fsfw/monitoring/MonitorBase.h
+++ b/src/fsfw/monitoring/MonitorBase.h
@@ -1,11 +1,11 @@
 #ifndef FSFW_MONITORING_MONITORBASE_H_
 #define FSFW_MONITORING_MONITORBASE_H_
 
-#include "../datapoollocal/LocalPoolVariable.h"
 #include "LimitViolationReporter.h"
 #include "MonitorReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
+#include "fsfw/datapool/PoolVariable.h"
 #include "monitoringConf.h"
 
 /**
@@ -22,7 +22,7 @@
 template <typename T>
 class MonitorBase : public MonitorReporter<T> {
  public:
-  MonitorBase(object_id_t reporterId, uint8_t monitorId, gp_id_t globalPoolId,
+  MonitorBase(object_id_t reporterId, uint8_t monitorId, dp::g_id_t globalPoolId,
               uint16_t confirmationLimit)
       : MonitorReporter<T>(reporterId, monitorId, globalPoolId, confirmationLimit),
         poolVariable(globalPoolId) {}
@@ -59,14 +59,11 @@ class MonitorBase : public MonitorReporter<T> {
     if (result != returnvalue::OK) {
       return result;
     }
-    if (not poolVariable.isValid()) {
-      return MonitoringIF::INVALID;
-    }
     *sample = poolVariable.value;
     return returnvalue::OK;
   }
 
-  LocalPoolVariable<T> poolVariable;
+  dp::PoolVariable<T> poolVariable;
 };
 
 #endif /* FSFW_MONITORING_MONITORBASE_H_ */
diff --git a/src/fsfw/monitoring/MonitorReporter.h b/src/fsfw/monitoring/MonitorReporter.h
index 09c39222..127e8f64 100644
--- a/src/fsfw/monitoring/MonitorReporter.h
+++ b/src/fsfw/monitoring/MonitorReporter.h
@@ -1,12 +1,11 @@
-#ifndef FSFW_MONITORING_MONITORREPORTER_H_
-#define FSFW_MONITORING_MONITORREPORTER_H_
+#pragma once
 
-#include "../datapoollocal/localPoolDefinitions.h"
 #include "../events/EventManagerIF.h"
 #include "../parameters/HasParametersIF.h"
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "MonitoringMessageContent.h"
+#include "fsfw/datapool/definitions.h"
 #include "monitoringConf.h"
 
 template <typename T>
@@ -17,7 +16,7 @@ class MonitorReporter : public HasParametersIF {
 
   // TODO: Adapt to use SID instead of parameter ID.
 
-  MonitorReporter(object_id_t reportingId, uint8_t monitorId, gp_id_t globalPoolId,
+  MonitorReporter(object_id_t reportingId, uint8_t monitorId, dp::g_id_t globalPoolId,
                   uint16_t confirmationLimit)
       : monitorId(monitorId),
         globalPoolId(globalPoolId),
@@ -84,7 +83,7 @@ class MonitorReporter : public HasParametersIF {
 
  protected:
   const uint8_t monitorId;
-  const gp_id_t globalPoolId;
+  const dp::g_id_t globalPoolId;
   object_id_t reportingId;
   ReturnValue_t oldState;
 
@@ -161,6 +160,4 @@ class MonitorReporter : public HasParametersIF {
     }
     return returnvalue::OK;
   }
-};
-
-#endif /* FSFW_MONITORING_MONITORREPORTER_H_ */
+};
\ No newline at end of file
diff --git a/src/fsfw/monitoring/MonitoringMessageContent.h b/src/fsfw/monitoring/MonitoringMessageContent.h
index 7a7b5440..27919e62 100644
--- a/src/fsfw/monitoring/MonitoringMessageContent.h
+++ b/src/fsfw/monitoring/MonitoringMessageContent.h
@@ -1,7 +1,5 @@
-#ifndef FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_
-#define FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_
+#pragma once
 
-#include "../datapoollocal/localPoolDefinitions.h"
 #include "../objectmanager/ObjectManager.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
@@ -11,6 +9,7 @@
 #include "../timemanager/TimeWriterIF.h"
 #include "HasMonitorsIF.h"
 #include "MonitoringIF.h"
+#include "fsfw/datapool/definitions.h"
 #include "monitoringConf.h"
 
 namespace Factory {
@@ -29,7 +28,7 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
  public:
   SerializeElement<uint8_t> monitorId;
   SerializeElement<uint32_t> parameterObjectId;
-  SerializeElement<lp_id_t> localPoolId;
+  SerializeElement<dp::id_t> localPoolId;
   SerializeElement<T> parameterValue;
   SerializeElement<T> limitValue;
   SerializeElement<ReturnValue_t> oldState;
@@ -50,7 +49,7 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
         timeStamper(nullptr) {
     setAllNext();
   }
-  MonitoringReportContent(gp_id_t globalPoolId, T value, T limitValue, ReturnValue_t oldState,
+  MonitoringReportContent(dp::g_id_t globalPoolId, T value, T limitValue, ReturnValue_t oldState,
                           ReturnValue_t newState)
       : SerialLinkedListAdapter<SerializeIF>(&parameterObjectId),
         monitorId(0),
@@ -94,5 +93,3 @@ class MonitoringReportContent : public SerialLinkedListAdapter<SerializeIF> {
 };
 template <typename T>
 object_id_t MonitoringReportContent<T>::timeStamperId = 0;
-
-#endif /* FSFW_MONITORING_MONITORINGMESSAGECONTENT_H_ */
diff --git a/src/fsfw/osal/host/Clock.cpp b/src/fsfw/osal/host/Clock.cpp
index 2a3c94bc..1515d472 100644
--- a/src/fsfw/osal/host/Clock.cpp
+++ b/src/fsfw/osal/host/Clock.cpp
@@ -54,9 +54,8 @@ ReturnValue_t Clock::getClockMonotonic(timeval* time) {
   // generic is kind of awkward..
   return returnvalue::FAILED;
 #elif defined(PLATFORM_UNIX)
-  timespec timeMonotonic;
-  int status = clock_gettime(CLOCK_MONOTONIC_RAW, &timeMonotonic);
-  if (status != 0) {
+  timespec timeMonotonic{};
+  if (const int status = clock_gettime(CLOCK_MONOTONIC_RAW, &timeMonotonic); status != 0) {
     return returnvalue::FAILED;
   }
   time->tv_sec = timeMonotonic.tv_sec;
diff --git a/src/fsfw/power/Fuse.cpp b/src/fsfw/power/Fuse.cpp
index 73b29452..898bb233 100644
--- a/src/fsfw/power/Fuse.cpp
+++ b/src/fsfw/power/Fuse.cpp
@@ -8,19 +8,16 @@
 
 object_id_t Fuse::powerSwitchId = 0;
 
-Fuse::Fuse(object_id_t fuseObjectId, uint8_t fuseId, sid_t variableSet, VariableIds ids,
-           float maxCurrent, uint16_t confirmationCount)
+Fuse::Fuse(object_id_t ownerId, object_id_t fuseObjectId, uint8_t fuseId,
+           dp::structure_id_t variableSet, VariableIds ids, float maxCurrent,
+           uint16_t confirmationCount)
     : SystemObject(fuseObjectId),
       oldFuseState(0),
       fuseId(fuseId),
       currentLimit(fuseObjectId, 1, ids.pidCurrent, confirmationCount, maxCurrent,
                    FUSE_CURRENT_HIGH),
       powerMonitor(fuseObjectId, 2, ids.poolIdPower, confirmationCount),
-      set(variableSet),
-      voltage(ids.pidVoltage, &set),
-      current(ids.pidCurrent, &set),
-      state(ids.pidState, &set),
-      power(ids.poolIdPower, &set, PoolVariableIF::VAR_READ_WRITE),
+      set(ownerId),
       parameterHelper(this),
       healthHelper(this, fuseObjectId) {
   commandQueue = QueueFactory::instance()->createMessageQueue();
@@ -63,20 +60,20 @@ ReturnValue_t Fuse::check() {
   set.read();
   if (!healthHelper.healthTable->isHealthy(getObjectId())) {
     setAllMonitorsToUnchecked();
-    set.setValidity(false, true);
+    set.setValid = false;
     return set.commit();
   }
   ReturnValue_t result = returnvalue::OK;
   checkFuseState();
   calculateFusePower();
   // Check if power is valid and if fuse state is off or invalid.
-  if (!power.isValid() || (state == 0) || !state.isValid()) {
+  if (!set.setValid.value || (set.state == 0)) {
     result = powerMonitor.setToInvalid();
   } else {
     float lowLimit = 0.0;
     float highLimit = RESIDUAL_POWER;
     calculatePowerLimits(&lowLimit, &highLimit);
-    result = powerMonitor.checkPower(power.value, lowLimit, highLimit);
+    result = powerMonitor.checkPower(set.power.value, lowLimit, highLimit);
     if (result == MonitoringIF::BELOW_LOW_LIMIT) {
       reportEvents(POWER_BELOW_LOW_LIMIT);
     } else if (result == MonitoringIF::ABOVE_HIGH_LIMIT) {
@@ -122,13 +119,12 @@ uint8_t Fuse::getFuseId() const { return fuseId; }
 
 void Fuse::calculateFusePower() {
   ReturnValue_t result1 = currentLimit.check();
-  if (result1 != returnvalue::OK || !(voltage.isValid())) {
-    power.setValid(PoolVariableIF::INVALID);
-    return;
+  if (result1 != returnvalue::OK || !(set.setValid.value)) {
+    set.powerValid = false;
   }
   // Calculate fuse power.
-  power.value = current.value * voltage.value;
-  power.setValid(PoolVariableIF::VALID);
+  set.power = set.current.value * set.voltage.value;
+  set.powerValid = true;
 }
 
 ReturnValue_t Fuse::performOperation(uint8_t opCode) {
@@ -173,21 +169,21 @@ void Fuse::checkCommandQueue() {
 }
 
 void Fuse::checkFuseState() {
-  if (!state.isValid()) {
+  if (!set.setValid.value) {
     oldFuseState = 0;
     return;
   }
-  if (state == 0) {
+  if (set.state == 0) {
     if (oldFuseState != 0) {
       reportEvents(FUSE_WENT_OFF);
     }
   }
-  oldFuseState = state.value;
+  oldFuseState = set.state.value;
 }
 
 float Fuse::getPower() {
-  if (power.isValid()) {
-    return power.value;
+  if (set.powerValid.value) {
+    return set.power.value;
   } else {
     return 0.0;
   }
@@ -195,7 +191,8 @@ float Fuse::getPower() {
 
 void Fuse::setDataPoolEntriesInvalid() {
   set.read();
-  set.setValidity(false, true);
+  set.setValid = false;
+  set.powerValid = false;
   set.commit();
 }
 
@@ -223,7 +220,7 @@ bool Fuse::areSwitchesOfComponentOn(DeviceList::iterator iter) {
   return true;
 }
 
-bool Fuse::isPowerValid() { return power.isValid(); }
+bool Fuse::isPowerValid() { return set.powerValid.value; }
 
 ReturnValue_t Fuse::setHealth(HealthState health) {
   healthHelper.setHealth(health);
diff --git a/src/fsfw/power/Fuse.h b/src/fsfw/power/Fuse.h
index c1b35899..908fbfc0 100644
--- a/src/fsfw/power/Fuse.h
+++ b/src/fsfw/power/Fuse.h
@@ -3,17 +3,44 @@
 
 #include <list>
 
-#include "../datapoollocal/StaticLocalDataSet.h"
-#include "../devicehandlers/HealthDevice.h"
-#include "../monitoring/AbsLimitMonitor.h"
-#include "../parameters/ParameterHelper.h"
-#include "../returnvalues/returnvalue.h"
 #include "PowerComponentIF.h"
 #include "PowerSwitchIF.h"
+#include "fsfw/datapool/StaticSharedSet.h"
+#include "fsfw/devicehandlers/HealthDevice.h"
+#include "fsfw/monitoring/AbsLimitMonitor.h"
+#include "fsfw/parameters/ParameterHelper.h"
+#include "fsfw/returnvalues/returnvalue.h"
+
 namespace Factory {
 void setStaticFrameworkObjectIds();
 }
 
+enum FusePoolId {
+  VOLTAGE = 0,
+  CURRENT = 1,
+  STATE = 2,
+  POWER = 3,
+  POWER_VALID = 4,
+  SET_VALID = 5
+
+};
+
+class FuseSet : public datapool::StaticSharedSet<6> {
+ public:
+  static constexpr uint8_t FUSE_SET_ID = 0;
+
+  FuseSet(dp::SharedPool &sharedPool) : StaticSharedSet(sharedPool, FUSE_SET_ID) {}
+
+  FuseSet(object_id_t objectId) : StaticSharedSet(dp::sid_t(objectId, FUSE_SET_ID)) {}
+
+  dp::f32_t voltage = dp::f32_t(sid.objectId, FusePoolId::VOLTAGE, this);
+  dp::f32_t current = dp::f32_t(sid.objectId, FusePoolId::CURRENT, this);
+  dp::u8_t state = dp::u8_t(sid.objectId, FusePoolId::STATE, this);
+  dp::f32_t power = dp::f32_t(sid.objectId, FusePoolId::POWER, this);
+  dp::u8_t powerValid = dp::u8_t(sid.objectId, FusePoolId::POWER_VALID, this);
+  dp::u8_t setValid = dp::u8_t(sid.objectId, FusePoolId::SET_VALID, this);
+};
+
 class Fuse : public SystemObject,
              public HasHealthIF,
              public ReceivesParameterMessagesIF,
@@ -26,10 +53,10 @@ class Fuse : public SystemObject,
                      //!< Worst case is Fuse and one of two switches on. See PCDU ICD 1.9 p29 bottom
  public:
   struct VariableIds {
-    gp_id_t pidVoltage;
-    gp_id_t pidCurrent;
-    gp_id_t pidState;
-    gp_id_t poolIdPower;
+    dp::g_id_t pidVoltage;
+    dp::g_id_t pidCurrent;
+    dp::g_id_t pidState;
+    dp::g_id_t poolIdPower;
   };
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::POWER_SWITCH_IF;
@@ -43,8 +70,8 @@ class Fuse : public SystemObject,
   static const Event POWER_BELOW_LOW_LIMIT = MAKE_EVENT(5, severity::LOW);
 
   typedef std::list<PowerComponentIF *> DeviceList;
-  Fuse(object_id_t fuseObjectId, uint8_t fuseId, sid_t variableSet, VariableIds ids,
-       float maxCurrent, uint16_t confirmationCount = 2);
+  Fuse(object_id_t ownerId, object_id_t fuseObjectId, uint8_t fuseId, dp::sid_t variableSet,
+       VariableIds ids, float maxCurrent, uint16_t confirmationCount = 2);
   virtual ~Fuse();
   void addDevice(PowerComponentIF *set);
   float getPower();
@@ -83,13 +110,8 @@ class Fuse : public SystemObject,
     void sendTransitionEvent(float currentValue, ReturnValue_t state) {}
   };
   PowerMonitor powerMonitor;
-  StaticLocalDataSet<3> set;
 
-  lp_var_t<float> voltage;
-  lp_var_t<float> current;
-  lp_var_t<uint8_t> state;
-
-  lp_var_t<float> power;
+  FuseSet set;
   MessageQueueIF *commandQueue = nullptr;
   ParameterHelper parameterHelper;
   HealthHelper healthHelper;
diff --git a/src/fsfw/power/PowerSensor.cpp b/src/fsfw/power/PowerSensor.cpp
index 69c9e272..e0083482 100644
--- a/src/fsfw/power/PowerSensor.cpp
+++ b/src/fsfw/power/PowerSensor.cpp
@@ -1,16 +1,15 @@
 #include "fsfw/power/PowerSensor.h"
 
+#include "definitions.h"
 #include "fsfw/ipc/QueueFactory.h"
 
-PowerSensor::PowerSensor(object_id_t objectId, sid_t setId, VariableIds ids, DefaultLimits limits,
-                         SensorEvents events, uint16_t confirmationCount)
+PowerSensor::PowerSensor(object_id_t objectId, dp::structure_id_t setId, VariableIds ids,
+                         DefaultLimits limits, SensorEvents events, uint16_t confirmationCount)
     : SystemObject(objectId),
       parameterHelper(this),
       healthHelper(this, objectId),
-      powerSensorSet(setId),
-      current(ids.pidCurrent, &powerSensorSet),
-      voltage(ids.pidVoltage, &powerSensorSet),
-      power(ids.poolIdPower, &powerSensorSet, PoolVariableIF::VAR_WRITE),
+      powerSensorSet(objectId),
+      // valid(ids.valid, &powerSensorSet),
       currentLimit(objectId, MODULE_ID_CURRENT, ids.pidCurrent, confirmationCount,
                    limits.currentMin, limits.currentMax, events.currentLow, events.currentHigh),
       voltageLimit(objectId, MODULE_ID_VOLTAGE, ids.pidVoltage, confirmationCount,
@@ -24,10 +23,9 @@ ReturnValue_t PowerSensor::calculatePower() {
   powerSensorSet.read();
   ReturnValue_t result1 = returnvalue::FAILED;
   ReturnValue_t result2 = returnvalue::FAILED;
-  if (healthHelper.healthTable->isHealthy(getObjectId()) && voltage.isValid() &&
-      current.isValid()) {
-    result1 = voltageLimit.doCheck(voltage.value);
-    result2 = currentLimit.doCheck(current.value);
+  if (healthHelper.healthTable->isHealthy(getObjectId()) && powerSensorSet.setIsValid.value) {
+    result1 = voltageLimit.doCheck(powerSensorSet.voltage.value);
+    result2 = currentLimit.doCheck(powerSensorSet.current.value);
   } else {
     voltageLimit.setToInvalid();
     currentLimit.setToInvalid();
@@ -35,10 +33,10 @@ ReturnValue_t PowerSensor::calculatePower() {
   }
   if (result1 != returnvalue::OK || result2 != returnvalue::OK) {
     result1 = MonitoringIF::INVALID;
-    power.setValid(PoolVariableIF::INVALID);
+    powerSensorSet.setIsValid = false;
   } else {
-    power.setValid(PoolVariableIF::VALID);
-    power.value = current.value * voltage.value;
+    powerSensorSet.setIsValid = true;
+    powerSensorSet.power = powerSensorSet.current.value * powerSensorSet.voltage.value;
   }
   powerSensorSet.commit();
   return result1;
@@ -92,13 +90,13 @@ void PowerSensor::checkCommandQueue() {
 
 void PowerSensor::setDataPoolEntriesInvalid() {
   powerSensorSet.read();
-  powerSensorSet.setValidity(false, true);
+  powerSensorSet.setIsValid = false;
   powerSensorSet.commit();
 }
 
 float PowerSensor::getPower() {
-  if (power.isValid()) {
-    return power.value;
+  if (powerSensorSet.setIsValid.value) {
+    return powerSensorSet.power.value;
   } else {
     return 0.0;
   }
diff --git a/src/fsfw/power/PowerSensor.h b/src/fsfw/power/PowerSensor.h
index 8e16d0b6..7c0dfa78 100644
--- a/src/fsfw/power/PowerSensor.h
+++ b/src/fsfw/power/PowerSensor.h
@@ -1,7 +1,7 @@
 #ifndef FSFW_POWER_POWERSENSOR_H_
 #define FSFW_POWER_POWERSENSOR_H_
 
-#include "fsfw/datapoollocal/StaticLocalDataSet.h"
+#include "fsfw/datapool/StaticSharedSet.h"
 #include "fsfw/devicehandlers/HealthDevice.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/monitoring/LimitMonitor.h"
@@ -10,6 +10,27 @@
 
 class PowerController;
 
+enum PowerSensorPoolId {
+  CURRENT = 0,
+  VOLTAGE = 1,
+  POWER = 2,
+  SET_VALID = 3
+
+};
+class PowerSensorSet : public dp::StaticSharedSet<6> {
+ public:
+  static constexpr uint8_t POWER_SENSOR_SET_ID = 0;
+
+  PowerSensorSet(dp::SharedPool &sharedPool) : StaticSharedSet(sharedPool, POWER_SENSOR_SET_ID) {}
+
+  PowerSensorSet(object_id_t objectId)
+      : StaticSharedSet(dp::sid_t(objectId, POWER_SENSOR_SET_ID)) {}
+
+  dp::f32_t current{sid.objectId, PowerSensorPoolId::CURRENT, this};
+  dp::f32_t voltage{sid.objectId, PowerSensorPoolId::VOLTAGE, this};
+  dp::f32_t power = {sid.objectId, PowerSensorPoolId::POWER, this};
+  dp::u8_t setIsValid{sid.objectId, PowerSensorPoolId::SET_VALID, this};
+};
 /**
  * @brief	Does magic.
  */
@@ -18,9 +39,10 @@ class PowerSensor : public SystemObject, public ReceivesParameterMessagesIF, pub
 
  public:
   struct VariableIds {
-    gp_id_t pidCurrent;
-    gp_id_t pidVoltage;
-    gp_id_t poolIdPower;
+    dp::g_id_t pidCurrent;
+    dp::g_id_t pidVoltage;
+    dp::g_id_t poolIdPower;
+    dp::g_id_t valid;
   };
   struct DefaultLimits {
     float currentMin;
@@ -34,7 +56,7 @@ class PowerSensor : public SystemObject, public ReceivesParameterMessagesIF, pub
     Event voltageLow;
     Event voltageHigh;
   };
-  PowerSensor(object_id_t objectId, sid_t sid, VariableIds setIds, DefaultLimits limits,
+  PowerSensor(object_id_t objectId, dp::sid_t sid, VariableIds setIds, DefaultLimits limits,
               SensorEvents events, uint16_t confirmationCount = 0);
   virtual ~PowerSensor();
   ReturnValue_t calculatePower();
@@ -53,16 +75,7 @@ class PowerSensor : public SystemObject, public ReceivesParameterMessagesIF, pub
   MessageQueueIF *commandQueue = nullptr;
   ParameterHelper parameterHelper;
   HealthHelper healthHelper;
-  // GlobDataSet set;
-  StaticLocalDataSet<3> powerSensorSet;
-  // Variables in
-  lp_var_t<float> current;
-  lp_var_t<float> voltage;
-  // PIDReader<float> current;
-  // PIDReader<float> voltage;
-  // Variables out
-  lp_var_t<float> power;
-  // gp_float_t power;
+  PowerSensorSet powerSensorSet;
 
   static const uint8_t MODULE_ID_CURRENT = 1;
   static const uint8_t MODULE_ID_VOLTAGE = 2;
diff --git a/src/fsfw/pus/Service3Housekeeping.cpp b/src/fsfw/pus/Service3Housekeeping.cpp
index 328f5a25..87d7d6c2 100644
--- a/src/fsfw/pus/Service3Housekeeping.cpp
+++ b/src/fsfw/pus/Service3Housekeeping.cpp
@@ -1,9 +1,11 @@
 #include "fsfw/pus/Service3Housekeeping.h"
 
-#include "fsfw/datapoollocal/HasLocalDataPoolIF.h"
+#include "fsfw/housekeeping/GeneratesPeriodicHkIF.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/pus/servicepackets/Service3Packets.h"
 
+using namespace dp;
+
 Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid, uint8_t serviceId,
                                            uint32_t queueDepth, uint8_t numParallelCommands)
     : CommandingServiceBase(objectId, apid, "PUS 3 HK", serviceId, numParallelCommands,
@@ -58,8 +60,7 @@ ReturnValue_t Service3Housekeeping::checkAndAcquireTargetID(object_id_t* objectI
 ReturnValue_t Service3Housekeeping::checkInterfaceAndAcquireMessageQueue(
     MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
   // check HasLocalDataPoolIF property of target
-  HasLocalDataPoolIF* possibleTarget =
-      ObjectManager::instance()->get<HasLocalDataPoolIF>(*objectId);
+  auto* possibleTarget = ObjectManager::instance()->get<hk::GeneratesPeriodicHkIF>(*objectId);
   if (possibleTarget == nullptr) {
     return CommandingServiceBase::INVALID_OBJECT;
   }
@@ -99,12 +100,12 @@ ReturnValue_t Service3Housekeeping::prepareReportingTogglingCommand(CommandMessa
                                                                     bool enableReporting,
                                                                     const uint8_t* tcData,
                                                                     size_t tcDataLen) {
-  if (tcDataLen < sizeof(sid_t)) {
+  if (tcDataLen < sizeof(structure_id_t)) {
     // TC data should consist of object ID and set ID.
     return CommandingServiceBase::INVALID_TC;
   }
 
-  sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
+  structure_id_t targetSid = buildStructureId(objectId, &tcData, &tcDataLen);
   HousekeepingMessage::setToggleReportingCommand(command, targetSid, enableReporting);
   return returnvalue::OK;
 }
@@ -113,12 +114,12 @@ ReturnValue_t Service3Housekeeping::prepareStructureReportingCommand(CommandMess
                                                                      object_id_t objectId,
                                                                      const uint8_t* tcData,
                                                                      size_t tcDataLen) {
-  if (tcDataLen < sizeof(sid_t)) {
+  if (tcDataLen < sizeof(structure_id_t)) {
     // TC data should consist of object ID and set ID.
     return CommandingServiceBase::INVALID_TC;
   }
 
-  sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
+  structure_id_t targetSid = buildStructureId(objectId, &tcData, &tcDataLen);
   HousekeepingMessage::setStructureReportingCommand(command, targetSid);
   return returnvalue::OK;
 }
@@ -128,24 +129,24 @@ ReturnValue_t Service3Housekeeping::prepareOneShotReportCommand(CommandMessage*
 
                                                                 const uint8_t* tcData,
                                                                 size_t tcDataLen) {
-  if (tcDataLen < sizeof(sid_t)) {
+  if (tcDataLen < sizeof(structure_id_t)) {
     // TC data should consist of object ID and set ID.
     return CommandingServiceBase::INVALID_TC;
   }
 
-  sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
+  structure_id_t targetSid = buildStructureId(objectId, &tcData, &tcDataLen);
   HousekeepingMessage::setOneShotReportCommand(command, targetSid);
   return returnvalue::OK;
 }
 
 ReturnValue_t Service3Housekeeping::prepareCollectionIntervalModificationCommand(
     CommandMessage* command, object_id_t objectId, const uint8_t* tcData, size_t tcDataLen) {
-  if (tcDataLen < sizeof(sid_t) + sizeof(float)) {
+  if (tcDataLen < sizeof(structure_id_t) + sizeof(float)) {
     /* SID plus the size of the new collection interval. */
     return CommandingServiceBase::INVALID_TC;
   }
 
-  sid_t targetSid = buildSid(objectId, &tcData, &tcDataLen);
+  structure_id_t targetSid = buildStructureId(objectId, &tcData, &tcDataLen);
   float newCollectionInterval = 0;
   SerializeAdapter::deSerialize(&newCollectionInterval, &tcData, &tcDataLen,
                                 SerializeIF::Endianness::BIG);
@@ -276,7 +277,7 @@ ReturnValue_t Service3Housekeeping::generateHkReply(const CommandMessage* hkMess
                                                     uint8_t subserviceId) {
   store_address_t storeId;
 
-  sid_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId);
+  structure_id_t sid = HousekeepingMessage::getHkDataReply(hkMessage, &storeId);
   auto resultPair = ipcStore->getData(storeId);
   if (resultPair.first != returnvalue::OK) {
     return resultPair.first;
@@ -286,9 +287,9 @@ ReturnValue_t Service3Housekeeping::generateHkReply(const CommandMessage* hkMess
   return sendTmPacket(static_cast<uint8_t>(subserviceId), hkPacket.hkData, hkPacket.hkSize);
 }
 
-sid_t Service3Housekeeping::buildSid(object_id_t objectId, const uint8_t** tcData,
-                                     size_t* tcDataLen) {
-  sid_t targetSid;
+structure_id_t Service3Housekeeping::buildStructureId(object_id_t objectId, const uint8_t** tcData,
+                                                      size_t* tcDataLen) {
+  structure_id_t targetSid;
   targetSid.objectId = objectId;
   // skip deserialization of object ID, was already done.
   *tcData += sizeof(object_id_t);
diff --git a/src/fsfw/pus/Service3Housekeeping.h b/src/fsfw/pus/Service3Housekeeping.h
index f336a50a..93597d52 100644
--- a/src/fsfw/pus/Service3Housekeeping.h
+++ b/src/fsfw/pus/Service3Housekeeping.h
@@ -97,7 +97,8 @@ class Service3Housekeeping : public CommandingServiceBase, public AcceptsHkPacke
                                                              size_t tcDataLen);
 
   void handleUnrequestedReply(CommandMessage* reply) override;
-  sid_t buildSid(object_id_t objectId, const uint8_t** tcData, size_t* tcDataLen);
+  dp::structure_id_t buildStructureId(object_id_t objectId, const uint8_t** tcData,
+                                      size_t* tcDataLen);
 };
 
 #endif /* FSFW_PUS_SERVICE3HOUSEKEEPINGSERVICE_H_ */
diff --git a/src/fsfw/pus/servicepackets/Service3Packets.h b/src/fsfw/pus/servicepackets/Service3Packets.h
index d6c98b61..153bdfb7 100644
--- a/src/fsfw/pus/servicepackets/Service3Packets.h
+++ b/src/fsfw/pus/servicepackets/Service3Packets.h
@@ -11,11 +11,12 @@
  */
 class HkPacket {  //!< [EXPORT] : [SUBSERVICE] 25, 26
  public:
-  sid_t sid;              //!< [EXPORT] : [COMMENT] Structure ID (SID) of housekeeping data.
+  dp::sid_t sid;          //!< [EXPORT] : [COMMENT] Structure ID (SID) of housekeeping data.
   const uint8_t* hkData;  //!< [EXPORT] : [MAXSIZE] Deduced size
   size_t hkSize;          //!< [EXPORT] : [IGNORE]
 
-  HkPacket(sid_t sid, const uint8_t* data, size_t size) : sid(sid), hkData(data), hkSize(size) {}
+  HkPacket(dp::sid_t sid, const uint8_t* data, size_t size)
+      : sid(sid), hkData(data), hkSize(size) {}
 };
 
 #endif /* FSFW_PUS_SERVICEPACKETS_SERVICE3PACKETS_H_ */
diff --git a/src/fsfw/returnvalues/FwClassIds.h b/src/fsfw/returnvalues/FwClassIds.h
index 9a4fa992..45a1c3f7 100644
--- a/src/fsfw/returnvalues/FwClassIds.h
+++ b/src/fsfw/returnvalues/FwClassIds.h
@@ -68,9 +68,9 @@ enum : uint8_t {
   MUTEX_IF,                       // MUX
   MESSAGE_QUEUE_IF,               // MQI
   SEMAPHORE_IF,                   // SPH
-  LOCAL_POOL_OWNER_IF,            // LPIF
+  DATAPOOL_IF,                    // LPIF
   POOL_VARIABLE_IF,               // PVA
-  HOUSEKEEPING_MANAGER,           // HKM
+  PERIODIC_HK_IF,                 // HKM
   DLE_ENCODER,                    // DLEE
   PUS_SERVICE_3,                  // PUS3
   PUS_SERVICE_9,                  // PUS9
diff --git a/src/fsfw/serialize.h b/src/fsfw/serialize.h
index b74c3c32..8292616a 100644
--- a/src/fsfw/serialize.h
+++ b/src/fsfw/serialize.h
@@ -5,6 +5,8 @@
 #include "serialize/SerialArrayListAdapter.h"
 #include "serialize/SerialBufferAdapter.h"
 #include "serialize/SerialLinkedListAdapter.h"
+#include "serialize/SerializableList.h"
+#include "serialize/SerializableListElement.h"
 #include "serialize/SerializeElement.h"
 
 #endif /* FSFW_SERIALIZE_H_ */
diff --git a/src/fsfw/serialize/SerializableList.h b/src/fsfw/serialize/SerializableList.h
new file mode 100644
index 00000000..b1bcfa11
--- /dev/null
+++ b/src/fsfw/serialize/SerializableList.h
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <vector>
+
+#include "SerializeIF.h"
+
+namespace serialize {
+class List : public SerializeIF {
+ public:
+  void addSerializable(const std::reference_wrapper<SerializeIF> serializable) {
+    serializables.push_back(serializable);
+  }
+
+  size_t getNumberOfSerializables() const { return serializables.size(); }
+
+  [[nodiscard]] ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                        Endianness streamEndianness) const override {
+    ReturnValue_t result = returnvalue::OK;
+    for (auto &serializable : serializables) {
+      result = serializable.get().serialize(buffer, size, maxSize, streamEndianness);
+      if (result != returnvalue::OK) {
+        return result;
+      }
+    }
+    return result;
+  }
+
+  [[nodiscard]] ReturnValue_t serialize(uint8_t *buffer, size_t &serSize, size_t maxSize,
+                                        Endianness streamEndianness) const override {
+    return SerializeIF::serialize(buffer, serSize, maxSize, streamEndianness);
+  }
+
+  [[nodiscard]] size_t getSerializedSize() const override {
+    size_t size = 0;
+    for (auto &serializable : serializables) {
+      size += serializable.get().getSerializedSize();
+    }
+    return size;
+  }
+
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                            const Endianness streamEndianness) override {
+    ReturnValue_t result = returnvalue::OK;
+    for (auto &serializable : serializables) {
+      result = serializable.get().deSerialize(buffer, size, streamEndianness);
+      if (result != returnvalue::OK) {
+        return result;
+      }
+    }
+    return result;
+  }
+
+ private:
+  std::vector<std::reference_wrapper<SerializeIF>> serializables;
+};
+
+}  // namespace serialize
\ No newline at end of file
diff --git a/src/fsfw/serialize/SerializableListElement.h b/src/fsfw/serialize/SerializableListElement.h
new file mode 100644
index 00000000..b7bc0a66
--- /dev/null
+++ b/src/fsfw/serialize/SerializableListElement.h
@@ -0,0 +1,152 @@
+#pragma once
+
+#include <utility>
+
+#include "SerializableList.h"
+#include "SerializeAdapter.h"
+#include "SerializeIF.h"
+
+namespace serialize {
+
+template <typename T>
+class ListVariable : public SerializeIF {
+ public:
+  template <typename... Args>
+  explicit ListVariable(List& list, Args... args) : entry(std::forward<Args>(args)...) {
+    list.addSerializable(*this);
+  }
+  explicit ListVariable(List& list) : entry() { list.addSerializable(*this); }
+
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          Endianness streamEndianness) const override {
+    return SerializeAdapter::serialize(&entry, buffer, size, maxSize, streamEndianness);
+  }
+
+  [[nodiscard]] size_t getSerializedSize() const override {
+    return SerializeAdapter::getSerializedSize(&entry);
+  }
+
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            Endianness streamEndianness) override {
+    return SerializeAdapter::deSerialize(&entry, buffer, size, streamEndianness);
+  }
+
+  explicit operator T() { return entry; }
+
+  ListVariable& operator=(T newValue) {
+    entry = newValue;
+    return *this;
+  }
+
+  T* operator->() { return &entry; }
+
+  T get() const { return entry; }
+
+  T entry{};
+};
+
+template <typename T>
+using LVar = ListVariable<T>;
+
+using lvar_u8 = LVar<uint8_t>;
+using lvar_u16 = LVar<uint16_t>;
+using lvar_u32 = LVar<uint32_t>;
+using lvar_u64 = LVar<uint64_t>;
+using lvar_i8 = LVar<int8_t>;
+using lvar_i16 = LVar<int16_t>;
+using lvar_i32 = LVar<int32_t>;
+using lvar_i64 = LVar<int64_t>;
+using lvar_f32 = LVar<float>;
+using lvar_f64 = LVar<double>;
+
+template <typename T, size_t N>
+class ListVector : public SerializeIF {
+ public:
+  template <typename... Args>
+  explicit ListVector(List& list, Args... args) : entry(std::forward<Args>(args)...) {
+    list.addSerializable(*this);
+  }
+  explicit ListVector(List& list) : entry() { list.addSerializable(*this); }
+
+  ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                          Endianness streamEndianness) const override {
+    ReturnValue_t result = returnvalue::OK;
+    for (size_t i = 0; i < N; i++) {
+      result = SerializeAdapter::serialize(entry + i, buffer, size, maxSize, streamEndianness);
+      if (result != returnvalue::OK) {
+        return result;
+      }
+    }
+    return result;
+  }
+
+  [[nodiscard]] size_t getSerializedSize() const override {
+    return SerializeAdapter::getSerializedSize(entry) * N;
+  }
+
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            Endianness streamEndianness) override {
+    ReturnValue_t result = returnvalue::OK;
+    for (size_t i = 0; i < N; i++) {
+      result = SerializeAdapter::deSerialize(entry + i, buffer, size, streamEndianness);
+      if (result != returnvalue::OK) {
+        return result;
+      }
+    }
+    return result;
+  }
+
+  explicit operator T() { return entry; }
+
+  ListVector& operator=(T newValue[N]) {
+    entry = newValue;
+    return *this;
+  }
+
+  // Array subscript operator for access
+  T& operator[](size_t index) {
+    // No exceptions, so user takes care of index validation..
+    return entry[index];
+  }
+
+  const T& operator[](size_t index) const { return entry[index]; }
+
+  // Conversion operator
+  explicit operator T*() { return entry; }
+  explicit operator const T*() const { return entry; }
+
+  // Iterators for range-based for loops and STL compatibility
+  T* begin() { return std::begin(entry); }
+  T* end() { return std::end(entry); }
+  const T* begin() const { return std::begin(entry); }
+  const T* end() const { return std::end(entry); }
+  const T* cbegin() const { return std::begin(entry); }
+  const T* cend() const { return std::end(entry); }
+
+  // Additional utility methods
+  [[nodiscard]] constexpr size_t size() const { return N; }
+
+  T entry[N];
+};
+
+template <typename T, size_t N>
+using LVec = ListVector<T, N>;
+
+template <size_t N>
+using lvec_u8 = LVec<uint8_t, N>;
+template <size_t N>
+using lvec_u16 = LVec<uint16_t, N>;
+template <size_t N>
+using lvec_u32 = LVec<uint32_t, N>;
+template <size_t N>
+using lvec_i8 = LVec<int8_t, N>;
+template <size_t N>
+using lvec_i16 = LVec<int16_t, N>;
+template <size_t N>
+using lvec_i32 = LVec<int32_t, N>;
+template <size_t N>
+using lvec_f32 = LVec<float, N>;
+template <size_t N>
+using lvec_f64 = LVec<double, N>;
+
+}  // namespace serialize
diff --git a/src/fsfw/serialize/SerializeAdapter.h b/src/fsfw/serialize/SerializeAdapter.h
index 3c478271..d154edd8 100644
--- a/src/fsfw/serialize/SerializeAdapter.h
+++ b/src/fsfw/serialize/SerializeAdapter.h
@@ -68,8 +68,8 @@ class SerializeAdapter {
    *      - @c returnvalue::OK Successful serialization
    */
   template <typename T>
-  static ReturnValue_t serialize(const T *object, uint8_t *const buffer, size_t *serSize,
-                                 size_t maxSize, SerializeIF::Endianness streamEndianness) {
+  static ReturnValue_t serialize(const T *object, uint8_t *buffer, size_t *serSize, size_t maxSize,
+                                 SerializeIF::Endianness streamEndianness) {
     if (object == nullptr or buffer == nullptr) {
       return returnvalue::FAILED;
     }
diff --git a/src/fsfw/serialize/SerializeElement.h b/src/fsfw/serialize/SerializeElement.h
index 01b339f7..c2388de1 100644
--- a/src/fsfw/serialize/SerializeElement.h
+++ b/src/fsfw/serialize/SerializeElement.h
@@ -37,7 +37,7 @@ class SerializeElement : public SerializeIF, public LinkedElement<SerializeIF> {
     return SerializeAdapter::deSerialize(&entry, buffer, size, streamEndianness);
   }
 
-  operator T() { return entry; }
+  explicit operator T() { return entry; }
 
   SerializeElement<T> &operator=(T newValue) {
     entry = newValue;
diff --git a/src/fsfw/serialize/SerializeIF.h b/src/fsfw/serialize/SerializeIF.h
index 85c29827..e98ace12 100644
--- a/src/fsfw/serialize/SerializeIF.h
+++ b/src/fsfw/serialize/SerializeIF.h
@@ -35,6 +35,7 @@ class SerializeIF {
       MAKE_RETURN_CODE(3);  // !< There are too many elements to be deserialized
 
   virtual ~SerializeIF() = default;
+
   /**
    * @brief
    * Function to serialize the object into a buffer with maxSize. Size represents the written
@@ -61,13 +62,6 @@ class SerializeIF {
    */
   [[nodiscard]] virtual ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                                 Endianness streamEndianness) const = 0;
-  /**
-   * Forwards to regular @serialize call with big (network) endianness
-   */
-  [[nodiscard]] virtual ReturnValue_t serializeBe(uint8_t **buffer, size_t *size,
-                                                  size_t maxSize) const {
-    return serialize(buffer, size, maxSize, SerializeIF::Endianness::NETWORK);
-  }
 
   /**
    * Gets the size of a object if it would be serialized in a buffer
@@ -97,6 +91,15 @@ class SerializeIF {
    */
   virtual ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
                                     Endianness streamEndianness) = 0;
+
+  /**
+   * Forwards to regular @serialize call with big (network) endianness
+   */
+  [[nodiscard]] virtual ReturnValue_t serializeBe(uint8_t **buffer, size_t *size,
+                                                  size_t maxSize) const {
+    return serialize(buffer, size, maxSize, SerializeIF::Endianness::NETWORK);
+  }
+
   /**
    * Forwards to regular @deSerialize call with big (network) endianness
    */
diff --git a/src/fsfw/storagemanager/LocalPool.h b/src/fsfw/storagemanager/LocalPool.h
index f82acd54..d85a5da0 100644
--- a/src/fsfw/storagemanager/LocalPool.h
+++ b/src/fsfw/storagemanager/LocalPool.h
@@ -14,7 +14,7 @@
 #include "fsfw/storagemanager/StorageManagerIF.h"
 
 /**
- * @brief   The LocalPool class provides an intermediate data storage with
+ * @brief   The Manager class provides an intermediate data storage with
  *          a fixed pool size policy.
  * @details
  * The class implements the StorageManagerIF interface. While the total number
@@ -62,7 +62,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
    * many elements with that size are created on that page.
    * All regions are to zero on start up.
    * @param setObjectId   The object identifier to be set. This allows for
-   *                      multiple instances of LocalPool in the system.
+   *                      multiple instances of Manager in the system.
    * @param poolConfig
    * This is a set of pairs to configure the number of pages in the pool,
    * the size of an element on a page, the number of elements on a page
@@ -79,7 +79,7 @@ class LocalPool : public SystemObject, public StorageManagerIF {
   void setToSpillToHigherPools(bool enable);
 
   /**
-   * @brief	In the LocalPool's destructor all allocated memory is freed.
+   * @brief	In the Manager's destructor all allocated memory is freed.
    */
   ~LocalPool() override;
 
diff --git a/src/fsfw/storagemanager/PoolManager.h b/src/fsfw/storagemanager/PoolManager.h
index d4bb9f0d..10d7608c 100644
--- a/src/fsfw/storagemanager/PoolManager.h
+++ b/src/fsfw/storagemanager/PoolManager.h
@@ -13,10 +13,10 @@
  * with a lock. The developer can lock the pool with the provided API
  * if the lock needs to persists beyond the function call.
  *
- * Other than that, the class provides the same interface as the LocalPool
+ * Other than that, the class provides the same interface as the Manager
  * class. The class is always registered as a system object as it is assumed
  * it will always be used concurrently (if this is not the case, it is
- * recommended to use the LocalPool class instead).
+ * recommended to use the Manager class instead).
  * @author 	Bastian Baetz
  */
 class PoolManager : public LocalPool {
@@ -36,8 +36,8 @@ class PoolManager : public LocalPool {
   void setMutexTimeout(uint32_t mutexTimeoutMs);
 
   /**
-   * @brief 	LocalPool overrides for thread-safety. Decorator function
-   * 			which wraps LocalPool calls with a mutex protection.
+   * @brief 	Manager overrides for thread-safety. Decorator function
+   * 			which wraps Manager calls with a mutex protection.
    */
   ReturnValue_t deleteData(store_address_t) override;
   ReturnValue_t deleteData(uint8_t* buffer, size_t size, store_address_t* storeId) override;
diff --git a/src/fsfw/thermal/ThermalComponent.cpp b/src/fsfw/thermal/ThermalComponent.cpp
index e0077af2..b867283a 100644
--- a/src/fsfw/thermal/ThermalComponent.cpp
+++ b/src/fsfw/thermal/ThermalComponent.cpp
@@ -1,9 +1,9 @@
 #include "fsfw/thermal/ThermalComponent.h"
 
 ThermalComponent::ThermalComponent(object_id_t reportingObjectId, uint8_t domainId,
-                                   gp_id_t temperaturePoolId, gp_id_t targetStatePoolId,
-                                   gp_id_t currentStatePoolId, gp_id_t requestPoolId,
-                                   LocalPoolDataSetBase* dataSet, AbstractTemperatureSensor* sensor,
+                                   dp::g_id_t temperaturePoolId, dp::g_id_t targetStatePoolId,
+                                   dp::g_id_t currentStatePoolId, dp::g_id_t requestPoolId,
+                                   dp::SharedSetBase* dataSet, AbstractTemperatureSensor* sensor,
                                    AbstractTemperatureSensor* firstRedundantSensor,
                                    AbstractTemperatureSensor* secondRedundantSensor,
                                    ThermalModuleIF* thermalModule, Parameters parameters,
@@ -26,8 +26,7 @@ ReturnValue_t ThermalComponent::setTargetState(int8_t newState) {
   switch (newState) {
     case STATE_REQUEST_NON_OPERATIONAL:
       targetState = newState;
-      targetState.setValid(true);
-      targetState.commit(PoolVariableIF::VALID);
+      targetState.commit();
       return returnvalue::OK;
     default:
       return ThermalComponentCore::setTargetState(newState);
diff --git a/src/fsfw/thermal/ThermalComponent.h b/src/fsfw/thermal/ThermalComponent.h
index 3c53be64..c088e6d8 100644
--- a/src/fsfw/thermal/ThermalComponent.h
+++ b/src/fsfw/thermal/ThermalComponent.h
@@ -44,9 +44,10 @@ class ThermalComponent : public ThermalComponentCore {
    * @param parameters
    * @param priority
    */
-  ThermalComponent(object_id_t reportingObjectId, uint8_t domainId, gp_id_t temperaturePoolId,
-                   gp_id_t targetStatePoolId, gp_id_t currentStatePoolId, gp_id_t requestPoolId,
-                   LocalPoolDataSetBase *dataSet, AbstractTemperatureSensor *sensor,
+  ThermalComponent(object_id_t reportingObjectId, uint8_t domainId, dp::g_id_t temperaturePoolId,
+                   dp::g_id_t targetStatePoolId, dp::g_id_t currentStatePoolId,
+                   dp::g_id_t requestPoolId, dp::SharedSetBase *dataSet,
+                   AbstractTemperatureSensor *sensor,
                    AbstractTemperatureSensor *firstRedundantSensor,
                    AbstractTemperatureSensor *secondRedundantSensor, ThermalModuleIF *thermalModule,
                    Parameters parameters, Priority priority);
diff --git a/src/fsfw/thermal/ThermalComponentCore.cpp b/src/fsfw/thermal/ThermalComponentCore.cpp
index ef47f49f..9b678254 100644
--- a/src/fsfw/thermal/ThermalComponentCore.cpp
+++ b/src/fsfw/thermal/ThermalComponentCore.cpp
@@ -3,9 +3,10 @@
 #include "fsfw/thermal/tcsDefinitions.h"
 
 ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId, uint8_t domainId,
-                                           gp_id_t temperaturePoolId, gp_id_t targetStatePoolId,
-                                           gp_id_t currentStatePoolId, gp_id_t requestPoolId,
-                                           LocalPoolDataSetBase* dataSet, Parameters parameters,
+                                           dp::g_id_t temperaturePoolId,
+                                           dp::g_id_t targetStatePoolId,
+                                           dp::g_id_t currentStatePoolId, dp::g_id_t requestPoolId,
+                                           dp::SharedSetBase* dataSet, Parameters parameters,
                                            StateRequest initialTargetState)
     : temperature(temperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE),
       targetState(targetStatePoolId, dataSet, PoolVariableIF::VAR_READ),
@@ -20,7 +21,7 @@ ThermalComponentCore::ThermalComponentCore(object_id_t reportingObjectId, uint8_
   ReturnValue_t result = targetState.read();
   if (result == returnvalue::OK) {
     targetState = initialTargetState;
-    targetState.setValid(true);
+    // targetState.setValid(true);
     targetState.commit();
   }
   targetState.setReadWriteMode(PoolVariableIF::VAR_READ);
@@ -59,20 +60,20 @@ ThermalComponentIF::HeaterRequest ThermalComponentCore::performOperation(uint8_t
   temperature = getTemperature();
   updateMinMaxTemp();
   if (temperature != thermal::INVALID_TEMPERATURE) {
-    temperature.setValid(PoolVariableIF::VALID);
+    // temperature.setValid(PoolVariableIF::VALID);
     State state = getState(temperature.value, getParameters(), targetState.value);
     currentState = state;
     checkLimits(state);
     request = getHeaterRequest(targetState.value, temperature.value, getParameters());
   } else {
     temperatureMonitor.setToInvalid();
-    temperature.setValid(PoolVariableIF::INVALID);
+    // temperature.setValid(PoolVariableIF::INVALID);
     currentState = UNKNOWN;
     request = HEATER_DONT_CARE;
   }
-  currentState.setValid(PoolVariableIF::VALID);
+  // currentState.setValid(PoolVariableIF::VALID);
   heaterRequest = request;
-  heaterRequest.setValid(PoolVariableIF::VALID);
+  // heaterRequest.setValid(PoolVariableIF::VALID);
   return request;
 }
 
@@ -104,17 +105,17 @@ ReturnValue_t ThermalComponentCore::setTargetState(int8_t newState) {
     default:
       return INVALID_TARGET_STATE;
   }
-  targetState.setValid(true);
+  // targetState.setValid(true);
   targetState.commit();
   return returnvalue::OK;
 }
 
 void ThermalComponentCore::setOutputInvalid() {
   temperature = thermal::INVALID_TEMPERATURE;
-  temperature.setValid(PoolVariableIF::INVALID);
-  currentState.setValid(PoolVariableIF::INVALID);
+  // temperature.setValid(PoolVariableIF::INVALID);
+  // currentState.setValid(PoolVariableIF::INVALID);
   heaterRequest = HEATER_DONT_CARE;
-  heaterRequest.setValid(PoolVariableIF::INVALID);
+  // heaterRequest.setValid(PoolVariableIF::INVALID);
   temperatureMonitor.setToUnchecked();
 }
 
diff --git a/src/fsfw/thermal/ThermalComponentCore.h b/src/fsfw/thermal/ThermalComponentCore.h
index dcc6064b..1f15439a 100644
--- a/src/fsfw/thermal/ThermalComponentCore.h
+++ b/src/fsfw/thermal/ThermalComponentCore.h
@@ -5,7 +5,7 @@
 #include "ThermalComponentIF.h"
 #include "ThermalModule.h"
 #include "ThermalMonitorReporter.h"
-#include "fsfw/datapoollocal/LocalPoolVariable.h"
+#include "fsfw/datapool/PoolVariable.h"
 
 /**
  * @brief
@@ -36,9 +36,9 @@ class ThermalComponentCore : public ThermalComponentIF {
    * @param initialTargetState
    */
   ThermalComponentCore(
-      object_id_t reportingObjectId, uint8_t domainId, gp_id_t temperaturePoolId,
-      gp_id_t targetStatePoolId, gp_id_t currentStatePoolId, gp_id_t requestPoolId,
-      LocalPoolDataSetBase *dataSet, Parameters parameters,
+      object_id_t reportingObjectId, uint8_t domainId, dp::g_id_t temperaturePoolId,
+      dp::g_id_t targetStatePoolId, dp::g_id_t currentStatePoolId, dp::g_id_t requestPoolId,
+      dp::SharedSetBase *dataSet, Parameters parameters,
       StateRequest initialTargetState = ThermalComponentIF::STATE_REQUEST_OPERATIONAL);
 
   void addSensor(AbstractTemperatureSensor *firstRedundantSensor);
@@ -74,10 +74,10 @@ class ThermalComponentCore : public ThermalComponentIF {
   AbstractTemperatureSensor *secondRedundantSensor = nullptr;
   ThermalModuleIF *thermalModule = nullptr;
 
-  lp_var_t<float> temperature;
-  lp_var_t<int8_t> targetState;
-  lp_var_t<int8_t> currentState;
-  lp_var_t<uint8_t> heaterRequest;
+  dp::f32_t temperature;
+  dp::i8_t targetState;
+  dp::i8_t currentState;
+  dp::i8_t heaterRequest;
 
   bool isHeating = false;
 
diff --git a/src/fsfw/thermal/ThermalModule.cpp b/src/fsfw/thermal/ThermalModule.cpp
index 6f62a02b..2dcb7f43 100644
--- a/src/fsfw/thermal/ThermalModule.cpp
+++ b/src/fsfw/thermal/ThermalModule.cpp
@@ -4,8 +4,8 @@
 #include "fsfw/monitoring/MonitoringMessageContent.h"
 #include "fsfw/thermal/AbstractTemperatureSensor.h"
 
-ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId, gp_id_t currentStatePoolId,
-                             gp_id_t targetStatePoolId, LocalPoolDataSetBase* dataSet,
+ThermalModule::ThermalModule(dp::g_id_t moduleTemperaturePoolId, dp::g_id_t currentStatePoolId,
+                             dp::g_id_t targetStatePoolId, dp::SharedSetBase* dataSet,
                              Parameters parameters, RedundantHeater::Parameters heaterParameters)
     : oldStrategy(ACTIVE_SINGLE),
       parameters(parameters),
@@ -15,12 +15,12 @@ ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId, gp_id_t currentSta
   heater = new RedundantHeater(heaterParameters);
 }
 
-ThermalModule::ThermalModule(gp_id_t moduleTemperaturePoolId, LocalPoolDataSetBase* dataSet)
+ThermalModule::ThermalModule(dp::g_id_t moduleTemperaturePoolId, dp::SharedSetBase* dataSet)
     : oldStrategy(ACTIVE_SINGLE),
       parameters({0, 0}),
       moduleTemperature(moduleTemperaturePoolId, dataSet, PoolVariableIF::VAR_WRITE),
-      currentState(gp_id_t(), dataSet, PoolVariableIF::VAR_WRITE),
-      targetState(gp_id_t(), dataSet, PoolVariableIF::VAR_READ) {}
+      currentState(dp::g_id_t(), dataSet, PoolVariableIF::VAR_WRITE),
+      targetState(dp::g_id_t(), dataSet, PoolVariableIF::VAR_READ) {}
 
 ThermalModule::~ThermalModule() { delete heater; }
 
@@ -87,12 +87,13 @@ void ThermalModule::calculateTemperature() {
       numberOfValidSensors++;
     }
   }
+  // TODO: Reintroduce validity.
   if (numberOfValidSensors != 0) {
     moduleTemperature = moduleTemperature.value / numberOfValidSensors;
-    moduleTemperature.setValid(PoolVariableIF::VALID);
+    // moduleTemperature.setValid(PoolVariableIF::VALID);
   } else {
     moduleTemperature.value = thermal::INVALID_TEMPERATURE;
-    moduleTemperature.setValid(PoolVariableIF::INVALID);
+    // moduleTemperature.setValid(PoolVariableIF::INVALID);
   }
 }
 
@@ -194,7 +195,7 @@ void ThermalModule::initialize(PowerSwitchIF* powerSwitch) {
 }
 
 bool ThermalModule::calculateModuleHeaterRequestAndSetModuleStatus(Strategy strategy) {
-  currentState.setValid(PoolVariableIF::VALID);
+  // currentState.setValid(PoolVariableIF::VALID);
   if (moduleTemperature == thermal::INVALID_TEMPERATURE) {
     currentState = UNKNOWN;
     return false;
@@ -240,7 +241,7 @@ void ThermalModule::setHeating(bool on) {
       targetState.value = STATE_REQUEST_PASSIVE;
     }
   }
-  targetState.setValid(true);
+  // targetState.setValid(true);
 }
 
 void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component, bool isSafe) {
@@ -257,9 +258,9 @@ void ThermalModule::updateTargetTemperatures(ThermalComponentIF* component, bool
 
 void ThermalModule::setOutputInvalid() {
   moduleTemperature = thermal::INVALID_TEMPERATURE;
-  moduleTemperature.setValid(PoolVariableIF::INVALID);
-  currentState.setValid(PoolVariableIF::INVALID);
-  std::list<ComponentData>::iterator iter = components.begin();
+  // moduleTemperature.setValid(PoolVariableIF::INVALID);
+  // currentState.setValid(PoolVariableIF::INVALID);
+  auto iter = components.begin();
   for (; iter != components.end(); iter++) {
     iter->component->setOutputInvalid();
   }
diff --git a/src/fsfw/thermal/ThermalModule.h b/src/fsfw/thermal/ThermalModule.h
index 3a33be7f..bd3381ec 100644
--- a/src/fsfw/thermal/ThermalModule.h
+++ b/src/fsfw/thermal/ThermalModule.h
@@ -3,12 +3,12 @@
 
 #include <list>
 
-#include "../datapoollocal/LocalPoolDataSetBase.h"
-#include "../datapoollocal/LocalPoolVariable.h"
 #include "../devicehandlers/HealthDevice.h"
 #include "../events/EventReportingProxyIF.h"
 #include "RedundantHeater.h"
 #include "ThermalModuleIF.h"
+#include "fsfw/datapool/PoolVariable.h"
+#include "fsfw/datapool/SharedSetBase.h"
 #include "tcsDefinitions.h"
 
 class PowerSwitchIF;
@@ -25,11 +25,11 @@ class ThermalModule : public ThermalModuleIF {
     float hysteresis;
   };
 
-  ThermalModule(gp_id_t moduleTemperaturePoolId, gp_id_t currentStatePoolId,
-                gp_id_t targetStatePoolId, LocalPoolDataSetBase *dataSet, Parameters parameters,
+  ThermalModule(dp::g_id_t moduleTemperaturePoolId, dp::g_id_t currentStatePoolId,
+                dp::g_id_t targetStatePoolId, dp::SharedSetBase *dataSet, Parameters parameters,
                 RedundantHeater::Parameters heaterParameters);
 
-  ThermalModule(gp_id_t moduleTemperaturePoolId, LocalPoolDataSetBase *dataSet);
+  ThermalModule(dp::g_id_t moduleTemperaturePoolId, dp::SharedSetBase *dataSet);
 
   virtual ~ThermalModule();
 
@@ -70,12 +70,12 @@ class ThermalModule : public ThermalModuleIF {
 
   Parameters parameters;
 
-  lp_var_t<float> moduleTemperature;
+  dp::f32_t moduleTemperature;
 
   RedundantHeater *heater = nullptr;
 
-  lp_var_t<int8_t> currentState;
-  lp_var_t<int8_t> targetState;
+  dp::i8_t currentState;
+  dp::i8_t targetState;
 
   std::list<AbstractTemperatureSensor *> sensors;
   std::list<ComponentData> components;
diff --git a/src/fsfw_hal/CMakeLists.txt b/src/fsfw_hal/CMakeLists.txt
index 24d712aa..64a81eb7 100644
--- a/src/fsfw_hal/CMakeLists.txt
+++ b/src/fsfw_hal/CMakeLists.txt
@@ -1,4 +1,3 @@
-add_subdirectory(devicehandlers)
 add_subdirectory(common)
 add_subdirectory(host)
 
diff --git a/src/fsfw_hal/devicehandlers/CMakeLists.txt b/src/fsfw_hal/devicehandlers/CMakeLists.txt
deleted file mode 100644
index e5999ad5..00000000
--- a/src/fsfw_hal/devicehandlers/CMakeLists.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-target_sources(
-  ${LIB_FSFW_NAME} PRIVATE GyroL3GD20Handler.cpp MgmRM3100Handler.cpp
-                           MgmLIS3MDLHandler.cpp)
-
-add_subdirectory(devicedefinitions)
diff --git a/src/fsfw_hal/devicehandlers/devicedefinitions/CMakeLists.txt b/src/fsfw_hal/devicehandlers/devicedefinitions/CMakeLists.txt
deleted file mode 100644
index 2d874fb5..00000000
--- a/src/fsfw_hal/devicehandlers/devicedefinitions/CMakeLists.txt
+++ /dev/null
@@ -1 +0,0 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE gyroL3gHelpers.cpp mgmLis3Helpers.cpp)
diff --git a/src/fsfw_tests/integration/controller/TestController.cpp b/src/fsfw_tests/integration/controller/TestController.cpp
index 5e860d16..56cf5c9d 100644
--- a/src/fsfw_tests/integration/controller/TestController.cpp
+++ b/src/fsfw_tests/integration/controller/TestController.cpp
@@ -9,29 +9,28 @@ TestController::TestController(object_id_t objectId, size_t commandQueueDepth)
 
 TestController::~TestController() {}
 
-ReturnValue_t TestController::handleCommandMessage(CommandMessage *message) {
+ReturnValue_t TestController::handleCommandMessage(CommandMessage* message) {
   return returnvalue::OK;
 }
 
 void TestController::performControlOperation(uint8_t opCode) {}
 
-void TestController::handleChangedDataset(sid_t sid, store_address_t storeId, bool *clearMessage) {}
-
-void TestController::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
-                                               bool *clearMessage) {}
-
-LocalPoolDataSetBase *TestController::getDataSetHandle(sid_t sid) { return nullptr; }
-
-ReturnValue_t TestController::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                                      LocalDataPoolManager &poolManager) {
-  return returnvalue::OK;
-}
-
 ReturnValue_t TestController::initializeAfterTaskCreation() {
   return ExtendedControllerBase::initializeAfterTaskCreation();
 }
 
 ReturnValue_t TestController::checkModeCommand(Mode_t mode, Submode_t submode,
-                                               uint32_t *msToReachTheMode) {
+                                               uint32_t* msToReachTheMode) {
+  return returnvalue::OK;
+}
+
+datapool::SharedPool* TestController::getOptionalSharedPool() { return nullptr; }
+
+ReturnValue_t TestController::serializeHkDataset(dp::sid_t structureId, uint8_t* buf,
+                                                 size_t maxSize) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t TestController::specifyHkDatasets(std::vector<hk::SetSpecification>& setList) {
   return returnvalue::OK;
 }
diff --git a/src/fsfw_tests/integration/controller/TestController.h b/src/fsfw_tests/integration/controller/TestController.h
index 8fb9530d..12f8cbd7 100644
--- a/src/fsfw_tests/integration/controller/TestController.h
+++ b/src/fsfw_tests/integration/controller/TestController.h
@@ -16,14 +16,11 @@ class TestController : public ExtendedControllerBase {
   void performControlOperation(uint8_t opCode) override;
 
   // HasLocalDatapoolIF callbacks
-  virtual void handleChangedDataset(sid_t sid, store_address_t storeId,
-                                    bool* clearMessage) override;
-  virtual void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
-                                         bool* clearMessage) override;
+  datapool::SharedPool* getOptionalSharedPool() override;
 
-  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
-  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                        LocalDataPoolManager& poolManager) override;
+  ReturnValue_t serializeHkDataset(dp::sid_t structureId, uint8_t* buf, size_t maxSize) override;
+
+  ReturnValue_t specifyHkDatasets(std::vector<hk::SetSpecification>& setList) override;
 
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                  uint32_t* msToReachTheMode) override;
diff --git a/src/fsfw_tests/integration/devices/TestDeviceHandler.cpp b/src/fsfw_tests/integration/devices/TestDeviceHandler.cpp
index b6a6f465..fb1ea7e8 100644
--- a/src/fsfw_tests/integration/devices/TestDeviceHandler.cpp
+++ b/src/fsfw_tests/integration/devices/TestDeviceHandler.cpp
@@ -10,7 +10,6 @@ TestDevice::TestDevice(object_id_t objectId, object_id_t comIF, CookieIF* cookie
                        bool changingDataset)
     : DeviceHandlerBase(objectId, comIF, cookie),
       deviceIdx(deviceIdx),
-      dataset(this),
       fullInfoPrintout(fullInfoPrintout) {}
 
 TestDevice::~TestDevice() = default;
@@ -158,46 +157,6 @@ ReturnValue_t TestDevice::buildCommandFromCommand(DeviceCommandId_t deviceComman
       result = buildTestCommand1(deviceCommand, commandData, commandDataLen);
       break;
     }
-    case (TEST_NOTIF_SNAPSHOT_VAR): {
-      if (changingDatasets) {
-        changingDatasets = false;
-      }
-
-      PoolReadGuard readHelper(&dataset.testUint8Var);
-      if (deviceIdx == testdevice::DeviceIndex::DEVICE_0) {
-        /* This will trigger a variable notification to the demo controller */
-        dataset.testUint8Var = 220;
-        dataset.testUint8Var.setValid(true);
-      } else if (deviceIdx == testdevice::DeviceIndex::DEVICE_1) {
-        /* This will trigger a variable snapshot to the demo controller */
-        dataset.testUint8Var = 30;
-        dataset.testUint8Var.setValid(true);
-      }
-
-      break;
-    }
-    case (TEST_NOTIF_SNAPSHOT_SET): {
-      if (changingDatasets) {
-        changingDatasets = false;
-      }
-
-      PoolReadGuard readHelper(&dataset.testFloat3Vec);
-
-      if (deviceIdx == testdevice::DeviceIndex::DEVICE_0) {
-        /* This will trigger a variable notification to the demo controller */
-        dataset.testFloat3Vec.value[0] = 60;
-        dataset.testFloat3Vec.value[1] = 70;
-        dataset.testFloat3Vec.value[2] = 55;
-        dataset.testFloat3Vec.setValid(true);
-      } else if (deviceIdx == testdevice::DeviceIndex::DEVICE_1) {
-        /* This will trigger a variable notification to the demo controller */
-        dataset.testFloat3Vec.value[0] = -60;
-        dataset.testFloat3Vec.value[1] = -70;
-        dataset.testFloat3Vec.value[2] = -55;
-        dataset.testFloat3Vec.setValid(true);
-      }
-      break;
-    }
     default:
       result = DeviceHandlerIF::COMMAND_NOT_SUPPORTED;
   }
@@ -313,7 +272,7 @@ void TestDevice::passOnCommand(DeviceCommandId_t command, const uint8_t* command
 
 void TestDevice::fillCommandAndReplyMap() {
   namespace td = testdevice;
-  insertInCommandAndReplyMap(testdevice::TEST_NORMAL_MODE_CMD, 5, &dataset);
+  insertInCommandAndReplyMap(testdevice::TEST_NORMAL_MODE_CMD, 5);
   insertInCommandAndReplyMap(testdevice::TEST_COMMAND_0, 5);
   insertInCommandAndReplyMap(testdevice::TEST_COMMAND_1, 5);
 
@@ -444,74 +403,48 @@ ReturnValue_t TestDevice::interpretDeviceReply(DeviceCommandId_t id, const uint8
 ReturnValue_t TestDevice::interpretingNormalModeReply() {
   CommandMessage directReplyMessage;
   if (changingDatasets) {
-    PoolReadGuard readHelper(&dataset);
-    if (dataset.testUint8Var.value == 0) {
-      dataset.testUint8Var.value = 10;
-      dataset.testUint32Var.value = 777;
-      dataset.testFloat3Vec.value[0] = 2.5;
-      dataset.testFloat3Vec.value[1] = -2.5;
-      dataset.testFloat3Vec.value[2] = 2.5;
-      dataset.setValidity(true, true);
+    if (dataset.testU8.get() == 0) {
+      dataset.testU8 = 10;
+      dataset.testU32 = 777;
+      dataset.testFloat3Vec[0] = 2.5;
+      dataset.testFloat3Vec[1] = -2.5;
+      dataset.testFloat3Vec[2] = 2.5;
     } else {
-      dataset.testUint8Var.value = 0;
-      dataset.testUint32Var.value = 0;
-      dataset.testFloat3Vec.value[0] = 0.0;
-      dataset.testFloat3Vec.value[1] = 0.0;
-      dataset.testFloat3Vec.value[2] = 0.0;
-      dataset.setValidity(false, true);
+      dataset.testU8 = 0;
+      dataset.testU32 = 0;
+      dataset.testFloat3Vec[0] = 0;
+      dataset.testFloat3Vec[1] = 0;
+      dataset.testFloat3Vec[2] = 0;
     }
     return returnvalue::OK;
-  }
-
-  PoolReadGuard readHelper(&dataset);
-  if (dataset.testUint8Var.value == 0) {
-    /* Reset state */
-    dataset.testUint8Var.value = 128;
-  } else if (dataset.testUint8Var.value > 200) {
-    if (not resetAfterChange) {
-      /* This will trigger an update notification to the controller */
-      dataset.testUint8Var.setChanged(true);
-      resetAfterChange = true;
-      /* Decrement by 30 automatically. This will prevent any additional notifications. */
-      dataset.testUint8Var.value -= 30;
-    }
-  }
-  /* If the value is greater than 0, it will be decremented in a linear way */
-  else if (dataset.testUint8Var.value > 128) {
+  } else if (dataset.testU8.get() > 128) {
+    // If the value is greater than 0, it will be decremented in a linear way
     size_t sizeToDecrement = 0;
-    if (dataset.testUint8Var.value > 128 + 30) {
+    if (dataset.testU8.get() > 128 + 30) {
       sizeToDecrement = 30;
     } else {
-      sizeToDecrement = dataset.testUint8Var.value - 128;
+      sizeToDecrement = dataset.testU8.get() - 128;
       resetAfterChange = false;
     }
-    dataset.testUint8Var.value -= sizeToDecrement;
-  } else if (dataset.testUint8Var.value < 50) {
-    if (not resetAfterChange) {
-      /* This will trigger an update snapshot to the controller */
-      dataset.testUint8Var.setChanged(true);
-      resetAfterChange = true;
-    } else {
-      /* Increment by 30 automatically. */
-      dataset.testUint8Var.value += 30;
-    }
-  }
-  /* Increment in linear way */
-  else if (dataset.testUint8Var.value < 128) {
+    dataset.testU8 = dataset.testU8.get() - sizeToDecrement;
+  } else if (dataset.testU8.get() < 50) {
+    // Increment by 30 automatically.
+    dataset.testU8 = dataset.testU8.get() + 30;
+  } else if (dataset.testU8.get() < 128) {
+    // Increment in linear way
     size_t sizeToIncrement = 0;
-    if (dataset.testUint8Var.value < 128 - 20) {
+    if (dataset.testU8.get() < 128 - 20) {
       sizeToIncrement = 20;
     } else {
-      sizeToIncrement = 128 - dataset.testUint8Var.value;
+      sizeToIncrement = 128 - dataset.testU8.get();
       resetAfterChange = false;
     }
-    dataset.testUint8Var.value += sizeToIncrement;
+    dataset.testU8 = dataset.testU8.get() + sizeToIncrement;
   }
 
   /* TODO: Same for vector */
-  float vectorMean = (dataset.testFloat3Vec.value[0] + dataset.testFloat3Vec.value[1] +
-                      dataset.testFloat3Vec.value[2]) /
-                     3.0;
+  float vectorMean =
+      (dataset.testFloat3Vec[0] + dataset.testFloat3Vec[1] + dataset.testFloat3Vec[2]) / 3.0;
 
   /* Lambda (private local function) */
   auto sizeToAdd = [](bool tooHigh, float currentVal) {
@@ -532,37 +465,35 @@ ReturnValue_t TestDevice::interpretingNormalModeReply() {
 
   if (vectorMean > 20.0 and std::abs(vectorMean - 20.0) > 1.0) {
     if (not resetAfterChange) {
-      dataset.testFloat3Vec.setChanged(true);
       resetAfterChange = true;
     } else {
       float sizeToDecrementVal0 = 0;
       float sizeToDecrementVal1 = 0;
       float sizeToDecrementVal2 = 0;
 
-      sizeToDecrementVal0 = sizeToAdd(true, dataset.testFloat3Vec.value[0]);
-      sizeToDecrementVal1 = sizeToAdd(true, dataset.testFloat3Vec.value[1]);
-      sizeToDecrementVal2 = sizeToAdd(true, dataset.testFloat3Vec.value[2]);
+      sizeToDecrementVal0 = sizeToAdd(true, dataset.testFloat3Vec[0]);
+      sizeToDecrementVal1 = sizeToAdd(true, dataset.testFloat3Vec[1]);
+      sizeToDecrementVal2 = sizeToAdd(true, dataset.testFloat3Vec[2]);
 
-      dataset.testFloat3Vec.value[0] += sizeToDecrementVal0;
-      dataset.testFloat3Vec.value[1] += sizeToDecrementVal1;
-      dataset.testFloat3Vec.value[2] += sizeToDecrementVal2;
+      dataset.testFloat3Vec[0] += sizeToDecrementVal0;
+      dataset.testFloat3Vec[1] += sizeToDecrementVal1;
+      dataset.testFloat3Vec[2] += sizeToDecrementVal2;
     }
   } else if (vectorMean < -20.0 and std::abs(vectorMean + 20.0) < 1.0) {
     if (not resetAfterChange) {
-      dataset.testFloat3Vec.setChanged(true);
       resetAfterChange = true;
     } else {
       float sizeToDecrementVal0 = 0;
       float sizeToDecrementVal1 = 0;
       float sizeToDecrementVal2 = 0;
 
-      sizeToDecrementVal0 = sizeToAdd(false, dataset.testFloat3Vec.value[0]);
-      sizeToDecrementVal1 = sizeToAdd(false, dataset.testFloat3Vec.value[1]);
-      sizeToDecrementVal2 = sizeToAdd(false, dataset.testFloat3Vec.value[2]);
+      sizeToDecrementVal0 = sizeToAdd(false, dataset.testFloat3Vec[0]);
+      sizeToDecrementVal1 = sizeToAdd(false, dataset.testFloat3Vec[1]);
+      sizeToDecrementVal2 = sizeToAdd(false, dataset.testFloat3Vec[2]);
 
-      dataset.testFloat3Vec.value[0] += sizeToDecrementVal0;
-      dataset.testFloat3Vec.value[1] += sizeToDecrementVal1;
-      dataset.testFloat3Vec.value[2] += sizeToDecrementVal2;
+      dataset.testFloat3Vec[0] += sizeToDecrementVal0;
+      dataset.testFloat3Vec[1] += sizeToDecrementVal1;
+      dataset.testFloat3Vec[2] += sizeToDecrementVal2;
     }
   } else {
     if (resetAfterChange) {
@@ -635,6 +566,7 @@ uint32_t TestDevice::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { retu
 
 void TestDevice::enableFullDebugOutput(bool enable) { this->fullInfoPrintout = enable; }
 
+/*
 ReturnValue_t TestDevice::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                   LocalDataPoolManager& poolManager) {
   namespace td = testdevice;
@@ -643,11 +575,12 @@ ReturnValue_t TestDevice::initializeLocalDataPool(localpool::DataPool& localData
   localDataPoolMap.emplace(td::PoolIds::TEST_FLOAT_VEC_3_ID, new PoolEntry<float>({0.0, 0.0, 0.0}));
 
   sid_t sid(this->getObjectId(), td::TEST_SET_ID);
-  /* Subscribe for periodic HK packets but do not enable reporting for now.
-  Non-diangostic with a period of one second */
-  poolManager.subscribeForRegularPeriodicPacket({sid, false, 1.0});
-  return returnvalue::OK;
+  // Subscribe for periodic HK packets but do not enable reporting for now.
+  //Non-diangostic with a period of one second
+poolManager.subscribeForRegularPeriodicPacket({sid, false, 1.0});
+return returnvalue::OK;
 }
+*/
 
 ReturnValue_t TestDevice::getParameter(uint8_t domainId, uint8_t uniqueId,
                                        ParameterWrapper* parameterWrapper,
@@ -747,12 +680,12 @@ ReturnValue_t TestDevice::getParameter(uint8_t domainId, uint8_t uniqueId,
         return result;
       }
       if (not enabled) {
-        PoolReadGuard readHelper(&dataset);
-        dataset.testUint8Var.value = 0;
-        dataset.testUint32Var.value = 0;
-        dataset.testFloat3Vec.value[0] = 0.0;
-        dataset.testFloat3Vec.value[0] = 0.0;
-        dataset.testFloat3Vec.value[1] = 0.0;
+        // PoolReadGuard readHelper(&dataset);
+        dataset.testU8 = 0;
+        dataset.testU32 = 0;
+        dataset.testFloat3Vec[0] = 0.0;
+        dataset.testFloat3Vec[0] = 0.0;
+        dataset.testFloat3Vec[1] = 0.0;
       }
 
       if (fullInfoPrintout) {
@@ -777,17 +710,4 @@ ReturnValue_t TestDevice::getParameter(uint8_t domainId, uint8_t uniqueId,
       return INVALID_IDENTIFIER_ID;
   }
   return returnvalue::OK;
-}
-
-LocalPoolObjectBase* TestDevice::getPoolObjectHandle(lp_id_t localPoolId) {
-  namespace td = testdevice;
-  if (localPoolId == td::PoolIds::TEST_UINT8_ID) {
-    return &dataset.testUint8Var;
-  } else if (localPoolId == td::PoolIds::TEST_UINT32_ID) {
-    return &dataset.testUint32Var;
-  } else if (localPoolId == td::PoolIds::TEST_FLOAT_VEC_3_ID) {
-    return &dataset.testFloat3Vec;
-  } else {
-    return nullptr;
-  }
-}
+}
\ No newline at end of file
diff --git a/src/fsfw_tests/integration/devices/TestDeviceHandler.h b/src/fsfw_tests/integration/devices/TestDeviceHandler.h
index 31931dad..09426792 100644
--- a/src/fsfw_tests/integration/devices/TestDeviceHandler.h
+++ b/src/fsfw_tests/integration/devices/TestDeviceHandler.h
@@ -85,10 +85,6 @@ class TestDevice : public DeviceHandlerBase {
 
   virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
 
-  virtual ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                                LocalDataPoolManager& poolManager) override;
-  virtual LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) override;
-
   /* HasParametersIF  overrides */
   virtual ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId,
                                      ParameterWrapper* parameterWrapper,
diff --git a/src/fsfw_tests/integration/devices/devicedefinitions/testDeviceDefinitions.h b/src/fsfw_tests/integration/devices/devicedefinitions/testDeviceDefinitions.h
index 00db9bd3..d6557cbc 100644
--- a/src/fsfw_tests/integration/devices/devicedefinitions/testDeviceDefinitions.h
+++ b/src/fsfw_tests/integration/devices/devicedefinitions/testDeviceDefinitions.h
@@ -1,8 +1,10 @@
 #ifndef MISSION_DEVICES_DEVICEDEFINITIONS_TESTDEVICEDEFINITIONS_H_
 #define MISSION_DEVICES_DEVICEDEFINITIONS_TESTDEVICEDEFINITIONS_H_
 
-#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <fsfw/datapool.h>
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/serialize/SerializableList.h>
+#include <fsfw/serialize/SerializableListElement.h>
 
 namespace testdevice {
 
@@ -67,21 +69,15 @@ static constexpr size_t TEST_COMMAND_0_SIZE = sizeof(TEST_COMMAND_0);
 static constexpr size_t TEST_COMMAND_1_SIZE =
     sizeof(TEST_COMMAND_1) + sizeof(COMMAND_1_PARAM1) + sizeof(COMMAND_1_PARAM2);
 
-enum PoolIds : lp_id_t { TEST_UINT8_ID = 0, TEST_UINT32_ID = 1, TEST_FLOAT_VEC_3_ID = 2 };
+enum PoolIds : dp::id_t { TEST_UINT8_ID = 0, TEST_UINT32_ID = 1, TEST_FLOAT_VEC_3_ID = 2 };
 
 static constexpr uint8_t TEST_SET_ID = TEST_NORMAL_MODE_CMD;
 
-class TestDataSet : public StaticLocalDataSet<3> {
+class TestDataSet : public serialize::List {
  public:
-  TestDataSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TEST_SET_ID) {}
-  TestDataSet(object_id_t owner) : StaticLocalDataSet(sid_t(owner, TEST_SET_ID)) {}
-
-  lp_var_t<uint8_t> testUint8Var =
-      lp_var_t<uint8_t>(gp_id_t(this->getCreatorObjectId(), PoolIds::TEST_UINT8_ID), this);
-  lp_var_t<uint32_t> testUint32Var =
-      lp_var_t<uint32_t>(gp_id_t(this->getCreatorObjectId(), PoolIds::TEST_UINT32_ID), this);
-  lp_vec_t<float, 3> testFloat3Vec =
-      lp_vec_t<float, 3>(gp_id_t(this->getCreatorObjectId(), PoolIds::TEST_FLOAT_VEC_3_ID), this);
+  serialize::LVar<uint8_t> testU8{*this};
+  serialize::LVar<uint32_t> testU32{*this};
+  serialize::LVec<float, 3> testFloat3Vec{*this};
 };
 
 }  // namespace testdevice
diff --git a/unittests/CMakeLists.txt b/unittests/CMakeLists.txt
index 950b96b8..abbe1d53 100644
--- a/unittests/CMakeLists.txt
+++ b/unittests/CMakeLists.txt
@@ -4,8 +4,7 @@ target_sources(${FSFW_TEST_TGT} PRIVATE CatchDefinitions.cpp CatchFactory.cpp
 target_sources(${FSFW_TEST_TGT} PRIVATE CatchRunner.cpp CatchSetup.cpp)
 
 add_subdirectory(testcfg)
-add_subdirectory(mocks)
-
+add_subdirectory(mock)
 add_subdirectory(tcdistributor)
 add_subdirectory(action)
 add_subdirectory(power)
@@ -15,7 +14,7 @@ add_subdirectory(osal)
 add_subdirectory(pus)
 add_subdirectory(subsystem)
 add_subdirectory(serialize)
-add_subdirectory(datapoollocal)
+add_subdirectory(datapool)
 add_subdirectory(storagemanager)
 add_subdirectory(globalfunctions)
 add_subdirectory(timemanager)
diff --git a/unittests/CatchFactory.cpp b/unittests/CatchFactory.cpp
index 10823636..b3d2ae1f 100644
--- a/unittests/CatchFactory.cpp
+++ b/unittests/CatchFactory.cpp
@@ -1,6 +1,6 @@
 #include "CatchFactory.h"
 
-#include <fsfw/datapoollocal/LocalDataPoolManager.h>
+// #include <fsfw/datapoollocal/LocalDataPoolManager.h>
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <fsfw/events/EventManager.h>
 #include <fsfw/health/HealthTable.h>
@@ -10,7 +10,7 @@
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
 #include <fsfw/tmtcservices/PusServiceBase.h>
 
-#include "mocks/HkReceiverMock.h"
+#include "mock/HkReceiverMock.h"
 #include "tests/TestsConfig.h"
 
 #if FSFW_ADD_DEFAULT_FACTORY_FUNCTIONS == 1
@@ -32,7 +32,7 @@ void Factory::produceFrameworkObjects(void* args) {
   setStaticFrameworkObjectIds();
   new EventManager(objects::EVENT_MANAGER, 80);
   new HealthTable(objects::HEALTH_TABLE);
-  new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER, 20, false, 5.0);
+  new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER, 20, false, 5000);
 
   {
     PoolManager::LocalPoolConfig poolCfg = {{100, 16}, {50, 32}, {25, 64}, {15, 128}, {5, 1024}};
@@ -57,7 +57,7 @@ void Factory::setStaticFrameworkObjectIds() {
   DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
   DeviceHandlerBase::rawDataReceiverId = objects::NO_OBJECT;
 
-  LocalDataPoolManager::defaultHkDestination = objects::NO_OBJECT;
+  // PeriodicHkGenerationHelper::defaultHkDestination = objects::NO_OBJECT;
   DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
 }
 
diff --git a/unittests/action/TestActionHelper.cpp b/unittests/action/TestActionHelper.cpp
index 3b22dcee..513008ba 100644
--- a/unittests/action/TestActionHelper.cpp
+++ b/unittests/action/TestActionHelper.cpp
@@ -6,12 +6,12 @@
 #include <array>
 #include <catch2/catch_test_macros.hpp>
 
-#include "mocks/MessageQueueMock.h"
+#include "mock/MessageQueueMock.h"
 
 TEST_CASE("Action Helper", "[action]") {
   ActionHelperOwnerMockBase testDhMock;
   // TODO: Setting another number here breaks the test. Find out why
-  MessageQueueMock testMqMock(MessageQueueIF::NO_QUEUE);
+  MessageQueueMock testMqMock(MessageQueueIF::NO_QUEUE, MessageQueueIF::NO_QUEUE);
   ActionHelper actionHelper = ActionHelper(&testDhMock, dynamic_cast<MessageQueueIF*>(&testMqMock));
   CommandMessage actionMessage;
   ActionId_t testActionId = 777;
diff --git a/unittests/cfdp/handler/testDestHandler.cpp b/unittests/cfdp/handler/testDestHandler.cpp
index c7ae5225..ccdf6fed 100644
--- a/unittests/cfdp/handler/testDestHandler.cpp
+++ b/unittests/cfdp/handler/testDestHandler.cpp
@@ -10,21 +10,21 @@
 #include "fsfw/cfdp/pdu/EofPduCreator.h"
 #include "fsfw/cfdp/pdu/FileDataCreator.h"
 #include "fsfw/cfdp/pdu/MetadataPduCreator.h"
-#include "mocks/AcceptsTmMock.h"
-#include "mocks/EventReportingProxyMock.h"
-#include "mocks/FilesystemMock.h"
-#include "mocks/MessageQueueMock.h"
-#include "mocks/StorageManagerMock.h"
-#include "mocks/cfdp/FaultHandlerMock.h"
-#include "mocks/cfdp/RemoteConfigTableMock.h"
-#include "mocks/cfdp/UserMock.h"
+#include "mock/AcceptsTmMock.h"
+#include "mock/EventReportingProxyMock.h"
+#include "mock/FilesystemMock.h"
+#include "mock/MessageQueueMock.h"
+#include "mock/StorageManagerMock.h"
+#include "mock/cfdp/FaultHandlerMock.h"
+#include "mock/cfdp/RemoteConfigTableMock.h"
+#include "mock/cfdp/UserMock.h"
 
 TEST_CASE("CFDP Dest Handler", "[cfdp]") {
   using namespace cfdp;
   using namespace returnvalue;
   MessageQueueId_t destQueueId = 2;
   AcceptsTmMock tmReceiver(destQueueId);
-  MessageQueueMock mqMock(destQueueId);
+  MessageQueueMock mqMock(destQueueId, MessageQueueIF::NO_QUEUE);
   auto localId = EntityId(UnsignedByteField<uint16_t>(2));
   auto remoteId = EntityId(UnsignedByteField<uint16_t>(3));
   FaultHandlerMock fhMock;
diff --git a/unittests/cfdp/handler/testDistributor.cpp b/unittests/cfdp/handler/testDistributor.cpp
index f6685c89..da9767b1 100644
--- a/unittests/cfdp/handler/testDistributor.cpp
+++ b/unittests/cfdp/handler/testDistributor.cpp
@@ -5,14 +5,14 @@
 #include "fsfw/cfdp/tlv/StringLv.h"
 #include "fsfw/storagemanager/LocalPool.h"
 #include "fsfw/tcdistribution/definitions.h"
-#include "mocks/AcceptsTcMock.h"
-#include "mocks/MessageQueueMock.h"
-#include "mocks/StorageManagerMock.h"
+#include "mock/AcceptsTcMock.h"
+#include "mock/MessageQueueMock.h"
+#include "mock/StorageManagerMock.h"
 
 TEST_CASE("CFDP Distributor", "[cfdp][distributor]") {
   LocalPool::LocalPoolConfig cfg = {{5, 32}, {2, 64}};
   StorageManagerMock pool(objects::NO_OBJECT, cfg);
-  auto queue = MessageQueueMock(1);
+  auto queue = MessageQueueMock(1, MessageQueueIF::NO_QUEUE);
   CfdpDistribCfg distribCfg(1, pool, &queue);
   auto distributor = CfdpDistributor(distribCfg);
   auto obswEntityId = cfdp::EntityId(UnsignedByteField<uint16_t>(2));
diff --git a/unittests/cfdp/handler/testFaultHandler.cpp b/unittests/cfdp/handler/testFaultHandler.cpp
index 5da9a70d..9770f71c 100644
--- a/unittests/cfdp/handler/testFaultHandler.cpp
+++ b/unittests/cfdp/handler/testFaultHandler.cpp
@@ -1,6 +1,6 @@
 #include <catch2/catch_test_macros.hpp>
 
-#include "mocks/cfdp/FaultHandlerMock.h"
+#include "mock/cfdp/FaultHandlerMock.h"
 
 TEST_CASE("CFDP Fault Handler", "[cfdp]") {
   using namespace cfdp;
diff --git a/unittests/cfdp/handler/testReservedMsgParser.cpp b/unittests/cfdp/handler/testReservedMsgParser.cpp
index 85aad8a2..a33dcf18 100644
--- a/unittests/cfdp/handler/testReservedMsgParser.cpp
+++ b/unittests/cfdp/handler/testReservedMsgParser.cpp
@@ -10,8 +10,8 @@
 #include "fsfw/cfdp/tlv/StringLv.h"
 #include "fsfw/globalfunctions/arrayprinter.h"
 #include "fsfw/serialize.h"
-#include "mocks/MessageQueueMock.h"
-#include "mocks/StorageManagerMock.h"
+#include "mock/MessageQueueMock.h"
+#include "mock/StorageManagerMock.h"
 
 TEST_CASE("Reserved Message Parser", "[cfdp]") {
   using namespace cfdp;
@@ -20,7 +20,7 @@ TEST_CASE("Reserved Message Parser", "[cfdp]") {
   std::string srcFileName = "hello.txt";
   std::string destFileName = "hello2.txt";
   MessageQueueId_t destQueueId = 2;
-  MessageQueueMock msgQueue(1);
+  MessageQueueMock msgQueue(1, destQueueId);
   LocalPool::LocalPoolConfig storeCfg = {{10, 32}, {10, 64}, {10, 128}, {10, 1024}};
   StorageManagerMock ipcStore(0, storeCfg);
   std::array<uint8_t, 128> buffer{};
diff --git a/unittests/cfdp/handler/testSourceHandler.cpp b/unittests/cfdp/handler/testSourceHandler.cpp
index 671a7508..17dc3849 100644
--- a/unittests/cfdp/handler/testSourceHandler.cpp
+++ b/unittests/cfdp/handler/testSourceHandler.cpp
@@ -15,14 +15,14 @@
 #include "fsfw/cfdp/pdu/MetadataPduReader.h"
 #include "fsfw/tmtcservices/TmTcMessage.h"
 #include "fsfw/util/SeqCountProvider.h"
-#include "mocks/AcceptsTmMock.h"
-#include "mocks/EventReportingProxyMock.h"
-#include "mocks/FilesystemMock.h"
-#include "mocks/MessageQueueMock.h"
-#include "mocks/StorageManagerMock.h"
-#include "mocks/cfdp/FaultHandlerMock.h"
-#include "mocks/cfdp/RemoteConfigTableMock.h"
-#include "mocks/cfdp/UserMock.h"
+#include "mock/AcceptsTmMock.h"
+#include "mock/EventReportingProxyMock.h"
+#include "mock/FilesystemMock.h"
+#include "mock/MessageQueueMock.h"
+#include "mock/StorageManagerMock.h"
+#include "mock/cfdp/FaultHandlerMock.h"
+#include "mock/cfdp/RemoteConfigTableMock.h"
+#include "mock/cfdp/UserMock.h"
 
 TEST_CASE("CFDP Source Handler", "[cfdp]") {
   using namespace cfdp;
diff --git a/unittests/datapoollocal/CMakeLists.txt b/unittests/datapool/CMakeLists.txt
similarity index 60%
rename from unittests/datapoollocal/CMakeLists.txt
rename to unittests/datapool/CMakeLists.txt
index 2c7a573f..ce00995a 100644
--- a/unittests/datapoollocal/CMakeLists.txt
+++ b/unittests/datapool/CMakeLists.txt
@@ -1,3 +1,3 @@
 target_sources(
   ${FSFW_TEST_TGT} PRIVATE testLocalPoolVariable.cpp testLocalPoolVector.cpp
-                           testDataSet.cpp testLocalPoolManager.cpp)
+                           testDataSet.cpp testPeriodicHkHelper.cpp)
diff --git a/unittests/datapool/testDataSet.cpp b/unittests/datapool/testDataSet.cpp
new file mode 100644
index 00000000..1a5940f3
--- /dev/null
+++ b/unittests/datapool/testDataSet.cpp
@@ -0,0 +1,148 @@
+#include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/datapool/SharedSet.h>
+#include <fsfw/globalfunctions/bitutility.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
+
+#include "CatchDefinitions.h"
+#include "mock/MessageQueueMock.h"
+#include "mock/TestPoolOwner.h"
+#include "tests/TestsConfig.h"
+
+using namespace returnvalue;
+using namespace lpool;
+
+TEST_CASE("DataSetTest", "[DataSetTest]") {
+  auto queue = MessageQueueMock(1, MessageQueueIF::NO_QUEUE);
+  TestPoolOwner poolOwner(queue, objects::TEST_LOCAL_POOL_OWNER_BASE);
+  poolOwner.initialize();
+  StaticTestDataset localSet;
+
+  SECTION("BasicTest") {
+    /* Test some basic functions */
+    CHECK(localSet.getReportingEnabled() == false);
+    CHECK(localSet.getLocalPoolIdsSerializedSize() == 3 * sizeof(dp::id_t));
+    CHECK(localSet.getStructureId() == lpool::testSid1);
+    CHECK(localSet.getCreatorObjectId() == objects::TEST_LOCAL_POOL_OWNER_BASE);
+    size_t maxSize = localSet.getLocalPoolIdsSerializedSize();
+    uint8_t localPoolIdBuff[maxSize];
+    // Skip size field
+    auto* lpIds = reinterpret_cast<id_t*>(localPoolIdBuff);
+    size_t serSize = 0;
+    auto* localPoolIdBuffPtr = reinterpret_cast<uint8_t*>(localPoolIdBuff);
+
+    // Test local pool ID serialization
+    CHECK(localSet.serializeLocalPoolIds(&localPoolIdBuffPtr, &serSize, maxSize,
+                                         SerializeIF::Endianness::MACHINE) == returnvalue::OK);
+    CHECK(serSize == maxSize);
+    // CHECK(localPoolIdBuff[0] == 3);
+    CHECK(lpIds[0] == localSet.localPoolVarUint8.getDataPoolId());
+    CHECK(lpIds[1] == localSet.localPoolVarFloat.getDataPoolId());
+    CHECK(lpIds[2] == localSet.localPoolUint16Vec.getDataPoolId());
+    // Now serialize without fill count
+    lpIds = reinterpret_cast<dp::id_t*>(localPoolIdBuff);
+    localPoolIdBuffPtr = localPoolIdBuff;
+    serSize = 0;
+    CHECK(localSet.serializeLocalPoolIds(&localPoolIdBuffPtr, &serSize, maxSize,
+                                         SerializeIF::Endianness::MACHINE) == OK);
+    CHECK(serSize == maxSize);
+    CHECK(lpIds[0] == localSet.localPoolVarUint8.getDataPoolId());
+    CHECK(lpIds[1] == localSet.localPoolVarFloat.getDataPoolId());
+    CHECK(lpIds[2] == localSet.localPoolUint16Vec.getDataPoolId());
+
+    {
+      // Test read operation. Values should be all zeros
+      PoolReadGuard readHelper(&localSet);
+      REQUIRE(readHelper.getReadResult() == returnvalue::OK);
+      CHECK(localSet.localPoolVarUint8.value == 0);
+      CHECK(localSet.localPoolVarFloat.value == Catch::Approx(0.0));
+      CHECK(localSet.localPoolUint16Vec.value[0] == 0);
+      CHECK(localSet.localPoolUint16Vec.value[1] == 0);
+      CHECK(localSet.localPoolUint16Vec.value[2] == 0);
+
+      // Now set new values, commit should be done by read helper automatically
+      localSet.localPoolVarUint8 = 232;
+      localSet.localPoolVarFloat = -2324.322;
+      localSet.localPoolUint16Vec.value[0] = 232;
+      localSet.localPoolUint16Vec.value[1] = 23923;
+      localSet.localPoolUint16Vec.value[2] = 1;
+    }
+
+    // Zero out some values for next test
+    localSet.localPoolVarUint8 = 0;
+    localSet.localPoolVarFloat = 0;
+
+    localSet.setAllVariablesReadOnly();
+    CHECK(localSet.localPoolUint16Vec.getReadWriteMode() == pool_rwm_t::VAR_READ);
+    CHECK(localSet.localPoolVarUint8.getReadWriteMode() == pool_rwm_t::VAR_READ);
+    CHECK(localSet.localPoolVarFloat.getReadWriteMode() == pool_rwm_t::VAR_READ);
+
+    {
+      // Now we read again and check whether our zeroed values were overwritten with
+      // the values in the pool
+      PoolReadGuard readHelper(&localSet);
+      REQUIRE(readHelper.getReadResult() == returnvalue::OK);
+      CHECK(localSet.localPoolVarUint8.value == 232);
+      CHECK(localSet.localPoolVarFloat.value == Catch::Approx(-2324.322));
+      CHECK(localSet.localPoolUint16Vec.value[0] == 232);
+      CHECK(localSet.localPoolUint16Vec.value[1] == 23923);
+      CHECK(localSet.localPoolUint16Vec.value[2] == 1);
+
+      // Now we serialize these values into a buffer without the validity buffer
+      maxSize = localSet.getSerializedSize();
+      CHECK(maxSize == sizeof(uint8_t) + sizeof(uint16_t) * 3 + sizeof(float));
+      serSize = 0;
+      // Already reserve additional space for validity buffer, will be needed later
+      uint8_t buffer[maxSize + 1];
+      uint8_t* buffPtr = buffer;
+      CHECK(localSet.serialize(&buffPtr, &serSize, maxSize, SerializeIF::Endianness::MACHINE) ==
+            returnvalue::OK);
+      uint8_t rawUint8 = buffer[0];
+      CHECK(rawUint8 == 232);
+      float rawFloat = 0.0;
+      std::memcpy(&rawFloat, buffer + sizeof(uint8_t), sizeof(float));
+      CHECK(rawFloat == Catch::Approx(-2324.322));
+
+      uint16_t rawUint16Vec[3];
+      std::memcpy(&rawUint16Vec, buffer + sizeof(uint8_t) + sizeof(float), 3 * sizeof(uint16_t));
+      CHECK(rawUint16Vec[0] == 232);
+      CHECK(rawUint16Vec[1] == 23923);
+      CHECK(rawUint16Vec[2] == 1);
+
+      size_t sizeToDeserialize = maxSize;
+      // Now we zeros out the raw entries and deserialize back into the dataset
+      std::memset(buffer, 0, sizeof(buffer));
+      const uint8_t* constBuffPtr = buffer;
+      CHECK(localSet.deSerialize(&constBuffPtr, &sizeToDeserialize,
+                                 SerializeIF::Endianness::MACHINE) == returnvalue::OK);
+      // Check whether deserialization was successfull
+      CHECK(localSet.localPoolVarUint8.value == 0);
+      CHECK(localSet.localPoolVarFloat.value == Catch::Approx(0.0));
+      CHECK(localSet.localPoolVarUint8.value == 0);
+      CHECK(localSet.localPoolUint16Vec.value[0] == 0);
+      CHECK(localSet.localPoolUint16Vec.value[1] == 0);
+      CHECK(localSet.localPoolUint16Vec.value[2] == 0);
+    }
+  }
+
+  SECTION("SharedDataSet") {
+    object_id_t sharedSetId = objects::SHARED_SET_ID;
+    SharedSet sharedSet(poolOwner.sharedPool, sharedSetId, 5);
+    localSet.localPoolVarUint8.setReadWriteMode(pool_rwm_t::VAR_WRITE);
+    localSet.localPoolUint16Vec.setReadWriteMode(pool_rwm_t::VAR_WRITE);
+    CHECK(sharedSet.registerVariable(&localSet.localPoolVarUint8) == returnvalue::OK);
+    CHECK(sharedSet.registerVariable(&localSet.localPoolUint16Vec) == returnvalue::OK);
+
+    {
+      PoolReadGuard rg(&sharedSet);
+      CHECK(rg.getReadResult() == returnvalue::OK);
+      localSet.localPoolVarUint8.value = 5;
+      localSet.localPoolUint16Vec.value[0] = 1;
+      localSet.localPoolUint16Vec.value[1] = 2;
+      localSet.localPoolUint16Vec.value[2] = 3;
+      CHECK(sharedSet.commit() == returnvalue::OK);
+    }
+  }
+}
diff --git a/unittests/datapoollocal/testLocalPoolVariable.cpp b/unittests/datapool/testLocalPoolVariable.cpp
similarity index 58%
rename from unittests/datapoollocal/testLocalPoolVariable.cpp
rename to unittests/datapool/testLocalPoolVariable.cpp
index ce125029..4345e047 100644
--- a/unittests/datapoollocal/testLocalPoolVariable.cpp
+++ b/unittests/datapool/testLocalPoolVariable.cpp
@@ -1,34 +1,31 @@
-#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
+#include <fsfw/housekeeping/PeriodicHkHelper.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 
 #include <catch2/catch_test_macros.hpp>
 
 #include "CatchDefinitions.h"
-#include "mocks/LocalPoolOwnerBase.h"
+#include "mock/TestPoolOwner.h"
 #include "tests/TestsConfig.h"
 
 using namespace returnvalue;
+using namespace lpool;
+using namespace dp;
 
 TEST_CASE("LocalPoolVariable", "[LocPoolVarTest]") {
-  auto queue = MessageQueueMock(1);
-  LocalPoolOwnerBase poolOwner(queue, objects::TEST_LOCAL_POOL_OWNER_BASE);
-  REQUIRE(poolOwner.initializeHkManager() == OK);
-  REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation() == OK);
+  auto queue = MessageQueueMock(1, MessageQueueIF::NO_QUEUE);
+  lpool::TestPoolOwner poolOwner(queue, objects::TEST_LOCAL_POOL_OWNER_BASE);
+  REQUIRE(poolOwner.initialize() == OK);
 
   SECTION("Basic Tests") {
     /* very basic test. */
-    lp_var_t<uint8_t> testVariable =
-        lp_var_t<uint8_t>(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+    u8_t testVariable{objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId};
     REQUIRE(testVariable.read() == returnvalue::OK);
     CHECK(testVariable.value == 0);
     testVariable.value = 5;
     REQUIRE(testVariable.commit() == returnvalue::OK);
     REQUIRE(testVariable.read() == returnvalue::OK);
     REQUIRE(testVariable.value == 5);
-    CHECK(not testVariable.isValid());
-    testVariable.setValid(true);
-    CHECK(testVariable.isValid());
-    CHECK(testVariable.commit(true) == returnvalue::OK);
+    CHECK(testVariable.commit() == returnvalue::OK);
 
     testVariable.setReadWriteMode(pool_rwm_t::VAR_READ);
     CHECK(testVariable.getReadWriteMode() == pool_rwm_t::VAR_READ);
@@ -38,12 +35,8 @@ TEST_CASE("LocalPoolVariable", "[LocPoolVarTest]") {
     CHECK(testVariable.getDataPoolId() == 22);
     testVariable.setDataPoolId(lpool::uint8VarId);
 
-    testVariable.setChanged(true);
-    CHECK(testVariable.hasChanged());
-    testVariable.setChanged(false);
-
-    gp_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
-    lp_var_t<uint8_t> testVariable2 = lp_var_t<uint8_t>(globPoolId);
+    g_id_t globPoolId(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+    u8_t testVariable2{globPoolId};
     REQUIRE(testVariable2.read() == returnvalue::OK);
     CHECK(testVariable2 == 5);
     CHECK(testVariable == testVariable2);
@@ -78,33 +71,30 @@ TEST_CASE("LocalPoolVariable", "[LocPoolVarTest]") {
 
   SECTION("ErrorHandling") {
     /* now try to use a local pool variable which does not exist */
-    lp_var_t<uint8_t> invalidVariable =
-        lp_var_t<uint8_t>(objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
-    REQUIRE(invalidVariable.read() == static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+    dp::u8_t invalidVariable{objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff};
+    REQUIRE(invalidVariable.read() == static_cast<int>(POOL_ENTRY_NOT_FOUND));
 
-    REQUIRE(invalidVariable.commit() == static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+    REQUIRE(invalidVariable.commit() == static_cast<int>(POOL_ENTRY_NOT_FOUND));
     /* now try to access with wrong type */
-    lp_var_t<int8_t> invalidVariable2 =
-        lp_var_t<int8_t>(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
-    REQUIRE(invalidVariable2.read() == static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+    dp::i8_t invalidVariable2 = dp::i8_t(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId);
+    REQUIRE(invalidVariable2.read() == static_cast<int>(POOL_ENTRY_TYPE_CONFLICT));
 
-    lp_var_t<uint8_t> readOnlyVar = lp_var_t<uint8_t>(
+    dp::var_t<uint8_t> readOnlyVar = dp::var_t<uint8_t>(
         objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId, nullptr, pool_rwm_t::VAR_READ);
     REQUIRE(readOnlyVar.commit() == static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
-    lp_var_t<uint8_t> writeOnlyVar = lp_var_t<uint8_t>(
+    dp::var_t<uint8_t> writeOnlyVar = dp::var_t<uint8_t>(
         objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint8VarId, nullptr, pool_rwm_t::VAR_WRITE);
     REQUIRE(writeOnlyVar.read() == static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
 
-    lp_var_t<uint32_t> uint32tVar =
-        lp_var_t<uint32_t>(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId);
+    dp::var_t<uint32_t> uint32tVar =
+        dp::var_t<uint32_t>(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint32VarId);
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::info << "LocalPoolVariable printout: " << uint32tVar << std::endl;
 #endif
 
     /* for code coverage. If program does not crash -> OK */
-    lp_var_t<uint8_t> invalidObjectVar = lp_var_t<uint8_t>(0xffffffff, lpool::uint8VarId);
-    gp_id_t globPoolId(0xffffffff, lpool::uint8VarId);
-    lp_var_t<uint8_t> invalidObjectVar2 = lp_var_t<uint8_t>(globPoolId);
-    lp_var_t<uint8_t> invalidObjectVar3 = lp_var_t<uint8_t>(nullptr, lpool::uint8VarId);
+    dp::var_t<uint8_t> invalidObjectVar = dp::var_t<uint8_t>(0xffffffff, lpool::uint8VarId);
+    dp::g_id_t globPoolId(0xffffffff, lpool::uint8VarId);
+    dp::var_t<uint8_t> invalidObjectVar2 = dp::var_t<uint8_t>(globPoolId);
   }
 }
diff --git a/unittests/datapoollocal/testLocalPoolVector.cpp b/unittests/datapool/testLocalPoolVector.cpp
similarity index 59%
rename from unittests/datapoollocal/testLocalPoolVector.cpp
rename to unittests/datapool/testLocalPoolVector.cpp
index 69014e58..994bb274 100644
--- a/unittests/datapoollocal/testLocalPoolVector.cpp
+++ b/unittests/datapool/testLocalPoolVector.cpp
@@ -1,31 +1,29 @@
-#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 
 #include <catch2/catch_test_macros.hpp>
 
 #include "CatchDefinitions.h"
-#include "mocks/LocalPoolOwnerBase.h"
+#include "mock/TestPoolOwner.h"
 #include "tests/TestsConfig.h"
 
 using namespace returnvalue;
+using namespace dp;
+using namespace lpool;
 
 TEST_CASE("LocalPoolVector", "[LocPoolVecTest]") {
-  auto queue = MessageQueueMock(1);
-  LocalPoolOwnerBase poolOwner(queue, objects::TEST_LOCAL_POOL_OWNER_BASE);
-  REQUIRE(poolOwner.initializeHkManager() == OK);
-  REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation() == OK);
+  auto queue = MessageQueueMock(1, MessageQueueIF::NO_QUEUE);
+  lpool::TestPoolOwner poolOwner(queue, objects::TEST_LOCAL_POOL_OWNER_BASE);
+  REQUIRE(poolOwner.initialize() == OK);
 
   SECTION("BasicTest") {
     // very basic test.
-    lp_vec_t<uint16_t, 3> testVector =
-        lp_vec_t<uint16_t, 3>(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
+    auto testVector = vec_t<uint16_t, 3>(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
     REQUIRE(testVector.read() == returnvalue::OK);
     testVector.value[0] = 5;
     testVector.value[1] = 232;
     testVector.value[2] = 32023;
 
-    REQUIRE(testVector.commit(true) == returnvalue::OK);
-    CHECK(testVector.isValid());
+    REQUIRE(testVector.commit() == returnvalue::OK);
 
     testVector.value[0] = 0;
     testVector.value[1] = 0;
@@ -45,7 +43,7 @@ TEST_CASE("LocalPoolVector", "[LocPoolVecTest]") {
     CHECK(testVector.commit() == returnvalue::OK);
 
     /* Use read-only reference. */
-    const lp_vec_t<uint16_t, 3>& roTestVec = testVector;
+    const dp::vec_t<uint16_t, 3>& roTestVec = testVector;
     uint16_t valueOne = roTestVec[0];
     CHECK(valueOne == 5);
 
@@ -56,7 +54,7 @@ TEST_CASE("LocalPoolVector", "[LocPoolVecTest]") {
     CHECK(maxSize == 6);
 
     uint16_t serializedVector[3];
-    uint8_t* vecPtr = reinterpret_cast<uint8_t*>(serializedVector);
+    auto* vecPtr = reinterpret_cast<uint8_t*>(serializedVector);
     size_t serSize = 0;
     REQUIRE(testVector.serialize(&vecPtr, &serSize, maxSize, SerializeIF::Endianness::MACHINE) ==
             returnvalue::OK);
@@ -74,7 +72,7 @@ TEST_CASE("LocalPoolVector", "[LocPoolVecTest]") {
     serializedVector[1] = 7832;
     serializedVector[2] = 39232;
 
-    const uint8_t* constVecPtr = reinterpret_cast<const uint8_t*>(serializedVector);
+    const auto* constVecPtr = reinterpret_cast<const uint8_t*>(serializedVector);
     REQUIRE(testVector.deSerialize(&constVecPtr, &serSize, SerializeIF::Endianness::MACHINE) ==
             returnvalue::OK);
     CHECK(testVector[0] == 16);
@@ -88,23 +86,21 @@ TEST_CASE("LocalPoolVector", "[LocPoolVecTest]") {
 
   SECTION("ErrorHandling") {
     /* Now try to use a local pool variable which does not exist */
-    lp_vec_t<uint16_t, 3> invalidVector =
-        lp_vec_t<uint16_t, 3>(objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff);
-    REQUIRE(invalidVector.read() == static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
-    REQUIRE(invalidVector.commit() == static_cast<int>(localpool::POOL_ENTRY_NOT_FOUND));
+    dp::vec_t<uint16_t, 3> invalidVector{objects::TEST_LOCAL_POOL_OWNER_BASE, 0xffffffff};
+    REQUIRE(invalidVector.read() == static_cast<int>(POOL_ENTRY_NOT_FOUND));
+    REQUIRE(invalidVector.commit() == static_cast<int>(POOL_ENTRY_NOT_FOUND));
 
     /* Now try to access with wrong type */
-    lp_vec_t<uint32_t, 3> invalidVector2 =
-        lp_vec_t<uint32_t, 3>(objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id);
-    REQUIRE(invalidVector2.read() == static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
-    REQUIRE(invalidVector2.commit() == static_cast<int>(localpool::POOL_ENTRY_TYPE_CONFLICT));
+    dp::vec_t<uint32_t, 3> invalidVector2{objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id};
+    REQUIRE(invalidVector2.read() == static_cast<int>(POOL_ENTRY_TYPE_CONFLICT));
+    REQUIRE(invalidVector2.commit() == static_cast<int>(POOL_ENTRY_TYPE_CONFLICT));
 
-    lp_vec_t<uint16_t, 3> writeOnlyVec = lp_vec_t<uint16_t, 3>(
-        objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id, nullptr, pool_rwm_t::VAR_WRITE);
+    dp::vec_t<uint16_t, 3> writeOnlyVec{objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
+                                        nullptr, pool_rwm_t::VAR_WRITE};
     REQUIRE(writeOnlyVec.read() == static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
 
-    lp_vec_t<uint16_t, 3> readOnlyVec = lp_vec_t<uint16_t, 3>(
-        objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id, nullptr, pool_rwm_t::VAR_READ);
+    dp::vec_t<uint16_t, 3> readOnlyVec = {objects::TEST_LOCAL_POOL_OWNER_BASE, lpool::uint16Vec3Id,
+                                          nullptr, pool_rwm_t::VAR_READ};
     REQUIRE(readOnlyVec.commit() == static_cast<int>(PoolVariableIF::INVALID_READ_WRITE_MODE));
   }
 }
diff --git a/unittests/datapool/testPeriodicHkHelper.cpp b/unittests/datapool/testPeriodicHkHelper.cpp
new file mode 100644
index 00000000..56b46a14
--- /dev/null
+++ b/unittests/datapool/testPeriodicHkHelper.cpp
@@ -0,0 +1,159 @@
+#include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/globalfunctions/timevalOperations.h>
+#include <fsfw/ipc/CommandMessageCleaner.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw/timemanager/CCSDSTime.h>
+
+#include <catch2/catch_approx.hpp>
+#include <catch2/catch_test_macros.hpp>
+#include <catch2/matchers/catch_matchers_floating_point.hpp>
+#include <iostream>
+
+#include "CatchDefinitions.h"
+#include "mock/HkReceiverMock.h"
+#include "mock/TestPoolOwner.h"
+
+using namespace lpool;
+
+TEST_CASE("Pool Owner and Periodic HK", "[datapool]") {
+  constexpr MessageQueueId_t DEFAULT_DEST_ID = 1;
+  constexpr MessageQueueId_t HK_DEST = DEFAULT_DEST_ID;
+  auto hkReceiver = HkReceiverMock(HK_DEST);
+  auto queue = MessageQueueMock(3, HK_DEST);
+  CommandMessage msg;
+  TestPoolOwner poolOwner(queue, HK_DEST, objects::TEST_LOCAL_POOL_OWNER_BASE);
+
+  REQUIRE(poolOwner.initialize() == returnvalue::OK);
+
+  MessageQueueMock& poolOwnerMock = poolOwner.getMockQueueHandle();
+  CommandMessage messageSent;
+
+  // TODO: Fix
+  SECTION("Basic Test") {
+    {
+      // For code coverage, should not crash
+      hk::PeriodicHelper manager(nullptr, nullptr);
+    }
+    auto owner = poolOwner.hkHelper.getOwner();
+    REQUIRE(owner != nullptr);
+    CHECK(owner->getObjectId() == objects::TEST_LOCAL_POOL_OWNER_BASE);
+
+    // Clear message to avoid memory leak, our mock won't do it for us (yet)
+    CommandMessageCleaner::clearCommandMessage(&messageSent);
+  }
+
+  SECTION("Periodic HK And Messaging") {
+    // Now we subcribe for a HK periodic generation. Even when it's difficult to simulate
+    // the temporal behaviour correctly the HK manager should generate a HK packet
+    // immediately and the periodic helper depends on HK op function calls anyway instead of
+    // using the clock, so we could also just call performHkOperation multiple times
+    REQUIRE(poolOwner.enablePeriodicHk(testSid0, 50) == returnvalue::OK);
+    REQUIRE(poolOwner.hkHelper.performHkOperation() == returnvalue::OK);
+    // Now HK packet should be sent as message immediately.
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
+    CHECK(poolOwnerMock.getNextSentMessageToDefaultDest(msg) == returnvalue::OK);
+    CHECK(msg.getCommand() == HousekeepingMessage::HK_REPORT);
+    auto structureId = HousekeepingMessage::getStructureId(&msg);
+    CHECK(structureId == testSid0);
+
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+    REQUIRE(poolOwner.hkHelper.performHkOperation() == returnvalue::OK);
+    // No packet should be generated now.
+    REQUIRE(!poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.numberOfSentMessages() == 0);
+
+    TaskFactory::delayTask(50);
+
+    // Should be generated again now.
+    REQUIRE(poolOwner.hkHelper.performHkOperation() == returnvalue::OK);
+    // No packet should be generated now.
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
+    CHECK(poolOwnerMock.getNextSentMessageToDefaultDest(msg) == returnvalue::OK);
+    CHECK(msg.getCommand() == HousekeepingMessage::HK_REPORT);
+    structureId = HousekeepingMessage::getStructureId(&msg);
+    CHECK(structureId == testSid0);
+  }
+
+  SECTION("Manual generation with API") {
+    // We can always generate a packet ourselves.
+    CHECK(poolOwner.hkHelper.generateHousekeepingPacket(lpool::testSid0) == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
+
+    CHECK(poolOwnerMock.getNextSentMessageToDefaultDest(msg) == returnvalue::OK);
+    auto structureId = HousekeepingMessage::getStructureId(&msg);
+    CHECK(structureId == testSid0);
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+  }
+
+  SECTION("Generation with Message") {
+    HousekeepingMessage::setOneShotReportCommand(&msg, lpool::testSid0);
+    CHECK(poolOwner.hkHelper.handleHousekeepingMessage(&msg) == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    CHECK(poolOwnerMock.getNextSentMessageToDefaultDest(msg) == returnvalue::OK);
+    auto structureId = HousekeepingMessage::getStructureId(&msg);
+    CHECK(structureId == testSid0);
+    poolOwnerMock.clearMessages();
+  }
+
+  SECTION("Toggle generation with message") {
+    HousekeepingMessage::setToggleReportingCommand(&msg, lpool::testSid0, false);
+    CHECK(poolOwner.hkHelper.handleHousekeepingMessage(&msg) == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
+    CHECK(poolOwnerMock.getNextSentMessageToDefaultDest(msg) == returnvalue::OK);
+    CHECK(msg.getCommand() == HousekeepingMessage::HK_REQUEST_SUCCESS);
+    auto structureId = HousekeepingMessage::getStructureId(&msg);
+    CHECK(structureId == testSid0);
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+    auto optSetSpec = poolOwner.hkHelper.getSetSpecification(testSid0);
+    REQUIRE(optSetSpec.has_value());
+    REQUIRE(!optSetSpec.value().get().collectionEnabled());
+
+    HousekeepingMessage::setToggleReportingCommand(&msg, lpool::testSid0, true);
+    CHECK(poolOwner.hkHelper.handleHousekeepingMessage(&msg) == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    CHECK(poolOwnerMock.getNextSentMessageToDefaultDest(msg) == returnvalue::OK);
+    CHECK(msg.getCommand() == HousekeepingMessage::HK_REQUEST_SUCCESS);
+    structureId = HousekeepingMessage::getStructureId(&msg);
+    CHECK(structureId == testSid0);
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+    REQUIRE(optSetSpec.has_value());
+    REQUIRE(optSetSpec.value().get().collectionEnabled());
+  }
+
+  SECTION("Modify collection interval with message") {
+    HousekeepingMessage::setCollectionIntervalModificationCommand(&msg, lpool::testSid0, 400);
+    CHECK(poolOwner.hkHelper.handleHousekeepingMessage(&msg) == returnvalue::OK);
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    CHECK(poolOwnerMock.getNextSentMessageToDefaultDest(msg) == returnvalue::OK);
+    CHECK(msg.getCommand() == HousekeepingMessage::HK_REQUEST_SUCCESS);
+    auto structureId = HousekeepingMessage::getStructureId(&msg);
+    CHECK(structureId == testSid0);
+    auto optSetSpec = poolOwner.hkHelper.getSetSpecification(testSid0);
+    REQUIRE(optSetSpec.has_value());
+    CHECK(optSetSpec.value().get().getCollectionFrequency() == 400);
+
+    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
+  }
+
+  SECTION("Structure reporting command") {
+    HousekeepingMessage::setStructureReportingCommand(&msg, lpool::testSid0);
+    REQUIRE(poolOwner.hkHelper.performHkOperation() == returnvalue::OK);
+    CHECK(poolOwner.hkHelper.handleHousekeepingMessage(&msg) == returnvalue::OK);
+    // Now HK packet should be sent as message.
+    REQUIRE(poolOwnerMock.wasMessageSent());
+    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
+    poolOwnerMock.clearMessages();
+  }
+
+  // we need to reset the subscription list because the pool owner
+  // is a global object.
+  CHECK(poolOwner.reset() == returnvalue::OK);
+  poolOwnerMock.clearMessages(true);
+}
\ No newline at end of file
diff --git a/unittests/datapoollocal/testDataSet.cpp b/unittests/datapoollocal/testDataSet.cpp
deleted file mode 100644
index 8bc0abb7..00000000
--- a/unittests/datapoollocal/testDataSet.cpp
+++ /dev/null
@@ -1,282 +0,0 @@
-#include <fsfw/datapool/PoolReadGuard.h>
-#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
-#include <fsfw/datapoollocal/SharedLocalDataSet.h>
-#include <fsfw/datapoollocal/StaticLocalDataSet.h>
-#include <fsfw/globalfunctions/bitutility.h>
-#include <fsfw/objectmanager/ObjectManager.h>
-
-#include <catch2/catch_approx.hpp>
-#include <catch2/catch_test_macros.hpp>
-
-#include "CatchDefinitions.h"
-#include "mocks/LocalPoolOwnerBase.h"
-#include "mocks/MessageQueueMock.h"
-#include "tests/TestsConfig.h"
-
-using namespace returnvalue;
-
-TEST_CASE("DataSetTest", "[DataSetTest]") {
-  auto queue = MessageQueueMock(1);
-  LocalPoolOwnerBase poolOwner(queue, objects::TEST_LOCAL_POOL_OWNER_BASE);
-  REQUIRE(poolOwner.initializeHkManager() == OK);
-  REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation() == OK);
-  LocalPoolStaticTestDataSet localSet;
-
-  SECTION("BasicTest") {
-    /* Test some basic functions */
-    CHECK(localSet.getReportingEnabled() == false);
-    CHECK(localSet.getLocalPoolIdsSerializedSize(false) == 3 * sizeof(lp_id_t));
-    CHECK(localSet.getLocalPoolIdsSerializedSize(true) == 3 * sizeof(lp_id_t) + sizeof(uint8_t));
-    CHECK(localSet.getSid() == lpool::testSid);
-    CHECK(localSet.getCreatorObjectId() == objects::TEST_LOCAL_POOL_OWNER_BASE);
-    size_t maxSize = localSet.getLocalPoolIdsSerializedSize(true);
-    uint8_t localPoolIdBuff[maxSize];
-    /* Skip size field */
-    auto* lpIds = reinterpret_cast<lp_id_t*>(localPoolIdBuff + 1);
-    size_t serSize = 0;
-    auto* localPoolIdBuffPtr = reinterpret_cast<uint8_t*>(localPoolIdBuff);
-
-    /* Test local pool ID serialization */
-    CHECK(localSet.serializeLocalPoolIds(&localPoolIdBuffPtr, &serSize, maxSize,
-                                         SerializeIF::Endianness::MACHINE) == returnvalue::OK);
-    CHECK(serSize == maxSize);
-    CHECK(localPoolIdBuff[0] == 3);
-    CHECK(lpIds[0] == localSet.localPoolVarUint8.getDataPoolId());
-    CHECK(lpIds[1] == localSet.localPoolVarFloat.getDataPoolId());
-    CHECK(lpIds[2] == localSet.localPoolUint16Vec.getDataPoolId());
-    /* Now serialize without fill count */
-    lpIds = reinterpret_cast<lp_id_t*>(localPoolIdBuff);
-    localPoolIdBuffPtr = localPoolIdBuff;
-    serSize = 0;
-    CHECK(localSet.serializeLocalPoolIds(&localPoolIdBuffPtr, &serSize, maxSize,
-                                         SerializeIF::Endianness::MACHINE, false) == OK);
-    CHECK(serSize == maxSize - sizeof(uint8_t));
-    CHECK(lpIds[0] == localSet.localPoolVarUint8.getDataPoolId());
-    CHECK(lpIds[1] == localSet.localPoolVarFloat.getDataPoolId());
-    CHECK(lpIds[2] == localSet.localPoolUint16Vec.getDataPoolId());
-
-    {
-      /* Test read operation. Values should be all zeros */
-      PoolReadGuard readHelper(&localSet);
-      REQUIRE(readHelper.getReadResult() == returnvalue::OK);
-      CHECK(not localSet.isValid());
-      CHECK(localSet.localPoolVarUint8.value == 0);
-      CHECK(not localSet.localPoolVarUint8.isValid());
-      CHECK(localSet.localPoolVarFloat.value == Catch::Approx(0.0));
-      CHECK(not localSet.localPoolVarUint8.isValid());
-      CHECK(localSet.localPoolUint16Vec.value[0] == 0);
-      CHECK(localSet.localPoolUint16Vec.value[1] == 0);
-      CHECK(localSet.localPoolUint16Vec.value[2] == 0);
-      CHECK(not localSet.localPoolVarUint8.isValid());
-
-      /* Now set new values, commit should be done by read helper automatically */
-      localSet.localPoolVarUint8 = 232;
-      localSet.localPoolVarFloat = -2324.322;
-      localSet.localPoolUint16Vec.value[0] = 232;
-      localSet.localPoolUint16Vec.value[1] = 23923;
-      localSet.localPoolUint16Vec.value[2] = 1;
-      localSet.setValidity(true, true);
-    }
-
-    /* Zero out some values for next test */
-    localSet.localPoolVarUint8 = 0;
-    localSet.localPoolVarFloat = 0;
-
-    localSet.setAllVariablesReadOnly();
-    CHECK(localSet.localPoolUint16Vec.getReadWriteMode() == pool_rwm_t::VAR_READ);
-    CHECK(localSet.localPoolVarUint8.getReadWriteMode() == pool_rwm_t::VAR_READ);
-    CHECK(localSet.localPoolVarFloat.getReadWriteMode() == pool_rwm_t::VAR_READ);
-
-    {
-      /* Now we read again and check whether our zeroed values were overwritten with
-      the values in the pool */
-      PoolReadGuard readHelper(&localSet);
-      REQUIRE(readHelper.getReadResult() == returnvalue::OK);
-      CHECK(localSet.isValid());
-      CHECK(localSet.localPoolVarUint8.value == 232);
-      CHECK(localSet.localPoolVarUint8.isValid());
-      CHECK(localSet.localPoolVarFloat.value == Catch::Approx(-2324.322));
-      CHECK(localSet.localPoolVarFloat.isValid());
-      CHECK(localSet.localPoolUint16Vec.value[0] == 232);
-      CHECK(localSet.localPoolUint16Vec.value[1] == 23923);
-      CHECK(localSet.localPoolUint16Vec.value[2] == 1);
-      CHECK(localSet.localPoolUint16Vec.isValid());
-
-      /* Now we serialize these values into a buffer without the validity buffer */
-      localSet.setValidityBufferGeneration(false);
-      maxSize = localSet.getSerializedSize();
-      CHECK(maxSize == sizeof(uint8_t) + sizeof(uint16_t) * 3 + sizeof(float));
-      serSize = 0;
-      /* Already reserve additional space for validity buffer, will be needed later */
-      uint8_t buffer[maxSize + 1];
-      uint8_t* buffPtr = buffer;
-      CHECK(localSet.serialize(&buffPtr, &serSize, maxSize, SerializeIF::Endianness::MACHINE) ==
-            returnvalue::OK);
-      uint8_t rawUint8 = buffer[0];
-      CHECK(rawUint8 == 232);
-      float rawFloat = 0.0;
-      std::memcpy(&rawFloat, buffer + sizeof(uint8_t), sizeof(float));
-      CHECK(rawFloat == Catch::Approx(-2324.322));
-
-      uint16_t rawUint16Vec[3];
-      std::memcpy(&rawUint16Vec, buffer + sizeof(uint8_t) + sizeof(float), 3 * sizeof(uint16_t));
-      CHECK(rawUint16Vec[0] == 232);
-      CHECK(rawUint16Vec[1] == 23923);
-      CHECK(rawUint16Vec[2] == 1);
-
-      size_t sizeToDeserialize = maxSize;
-      /* Now we zeros out the raw entries and deserialize back into the dataset */
-      std::memset(buffer, 0, sizeof(buffer));
-      const uint8_t* constBuffPtr = buffer;
-      CHECK(localSet.deSerialize(&constBuffPtr, &sizeToDeserialize,
-                                 SerializeIF::Endianness::MACHINE) == returnvalue::OK);
-      /* Check whether deserialization was successfull */
-      CHECK(localSet.localPoolVarUint8.value == 0);
-      CHECK(localSet.localPoolVarFloat.value == Catch::Approx(0.0));
-      CHECK(localSet.localPoolVarUint8.value == 0);
-      CHECK(localSet.localPoolUint16Vec.value[0] == 0);
-      CHECK(localSet.localPoolUint16Vec.value[1] == 0);
-      CHECK(localSet.localPoolUint16Vec.value[2] == 0);
-      /* Validity should be unchanged */
-      CHECK(localSet.localPoolVarUint8.isValid());
-      CHECK(localSet.localPoolVarFloat.isValid());
-      CHECK(localSet.localPoolUint16Vec.isValid());
-
-      /* Now we do the same process but with the validity buffer */
-      localSet.localPoolVarUint8 = 232;
-      localSet.localPoolVarFloat = -2324.322;
-      localSet.localPoolUint16Vec.value[0] = 232;
-      localSet.localPoolUint16Vec.value[1] = 23923;
-      localSet.localPoolUint16Vec.value[2] = 1;
-      localSet.localPoolVarUint8.setValid(true);
-      localSet.localPoolVarFloat.setValid(false);
-      localSet.localPoolUint16Vec.setValid(true);
-      localSet.setValidityBufferGeneration(true);
-      maxSize = localSet.getSerializedSize();
-      CHECK(maxSize == sizeof(uint8_t) + sizeof(uint16_t) * 3 + sizeof(float) + 1);
-      serSize = 0;
-      buffPtr = buffer;
-      CHECK(localSet.serialize(&buffPtr, &serSize, maxSize, SerializeIF::Endianness::MACHINE) ==
-            returnvalue::OK);
-      CHECK(rawUint8 == 232);
-      std::memcpy(&rawFloat, buffer + sizeof(uint8_t), sizeof(float));
-      CHECK(rawFloat == Catch::Approx(-2324.322));
-
-      std::memcpy(&rawUint16Vec, buffer + sizeof(uint8_t) + sizeof(float), 3 * sizeof(uint16_t));
-      CHECK(rawUint16Vec[0] == 232);
-      CHECK(rawUint16Vec[1] == 23923);
-      CHECK(rawUint16Vec[2] == 1);
-      /* We can do it like this because the buffer only has one byte for
-      less than 8 variables */
-      uint8_t* validityByte = buffer + sizeof(buffer) - 1;
-      bool bitSet = false;
-      bitutil::get(validityByte, 0, bitSet);
-
-      CHECK(bitSet == true);
-      bitutil::get(validityByte, 1, bitSet);
-      CHECK(bitSet == false);
-      bitutil::get(validityByte, 2, bitSet);
-      CHECK(bitSet == true);
-
-      /* Now we manipulate the validity buffer for the deserialization */
-      bitutil::clear(validityByte, 0);
-      bitutil::set(validityByte, 1);
-      bitutil::clear(validityByte, 2);
-      /* Zero out everything except validity buffer */
-      std::memset(buffer, 0, sizeof(buffer) - 1);
-      sizeToDeserialize = maxSize;
-      constBuffPtr = buffer;
-      CHECK(localSet.deSerialize(&constBuffPtr, &sizeToDeserialize,
-                                 SerializeIF::Endianness::MACHINE) == returnvalue::OK);
-      /* Check whether deserialization was successfull */
-      CHECK(localSet.localPoolVarUint8.value == 0);
-      CHECK(localSet.localPoolVarFloat.value == Catch::Approx(0.0));
-      CHECK(localSet.localPoolVarUint8.value == 0);
-      CHECK(localSet.localPoolUint16Vec.value[0] == 0);
-      CHECK(localSet.localPoolUint16Vec.value[1] == 0);
-      CHECK(localSet.localPoolUint16Vec.value[2] == 0);
-      CHECK(not localSet.localPoolVarUint8.isValid());
-      CHECK(localSet.localPoolVarFloat.isValid());
-      CHECK(not localSet.localPoolUint16Vec.isValid());
-    }
-
-    /* Common fault test cases */
-    LocalPoolObjectBase* variableHandle = poolOwner.getPoolObjectHandle(lpool::uint32VarId);
-    CHECK(variableHandle != nullptr);
-    CHECK(localSet.registerVariable(variableHandle) == static_cast<int>(DataSetIF::DATA_SET_FULL));
-    variableHandle = nullptr;
-    REQUIRE(localSet.registerVariable(variableHandle) ==
-            static_cast<int>(DataSetIF::POOL_VAR_NULL));
-  }
-
-  SECTION("MorePoolVariables") {
-    LocalDataSet set(&poolOwner, 2, 10);
-
-    /* Register same variables again to get more than 8 registered variables */
-    for (uint8_t idx = 0; idx < 8; idx++) {
-      REQUIRE(set.registerVariable(&localSet.localPoolVarUint8) == returnvalue::OK);
-    }
-    REQUIRE(set.registerVariable(&localSet.localPoolVarUint8) == returnvalue::OK);
-    REQUIRE(set.registerVariable(&localSet.localPoolUint16Vec) == returnvalue::OK);
-
-    set.setValidityBufferGeneration(true);
-    {
-      PoolReadGuard readHelper(&localSet);
-      localSet.localPoolVarUint8.value = 42;
-      localSet.localPoolVarUint8.setValid(true);
-      localSet.localPoolUint16Vec.setValid(false);
-    }
-
-    size_t maxSize = set.getSerializedSize();
-    CHECK(maxSize == 9 + sizeof(uint16_t) * 3 + 2);
-    size_t serSize = 0;
-    /* Already reserve additional space for validity buffer, will be needed later */
-    uint8_t buffer[maxSize + 1];
-    uint8_t* buffPtr = buffer;
-    CHECK(set.serialize(&buffPtr, &serSize, maxSize, SerializeIF::Endianness::MACHINE) == OK);
-    std::array<uint8_t, 2> validityBuffer{};
-    std::memcpy(validityBuffer.data(), buffer + 9 + sizeof(uint16_t) * 3, 2);
-    /* The first 9 variables should be valid */
-    CHECK(validityBuffer[0] == 0xff);
-    bool bitSet = false;
-    bitutil::get(validityBuffer.data() + 1, 0, bitSet);
-    CHECK(bitSet == true);
-    bitutil::get(validityBuffer.data() + 1, 1, bitSet);
-    CHECK(bitSet == false);
-
-    /* Now we invert the validity */
-    validityBuffer[0] = 0;
-    validityBuffer[1] = 0b0100'0000;
-    std::memcpy(buffer + 9 + sizeof(uint16_t) * 3, validityBuffer.data(), 2);
-    const uint8_t* constBuffPtr = buffer;
-    size_t sizeToDeSerialize = serSize;
-    CHECK(set.deSerialize(&constBuffPtr, &sizeToDeSerialize, SerializeIF::Endianness::MACHINE) ==
-          returnvalue::OK);
-    CHECK(localSet.localPoolVarUint8.isValid() == false);
-    CHECK(localSet.localPoolUint16Vec.isValid() == true);
-  }
-
-  SECTION("SharedDataSet") {
-    object_id_t sharedSetId = objects::SHARED_SET_ID;
-    SharedLocalDataSet sharedSet(sharedSetId, &poolOwner, lpool::testSetId, 5);
-    localSet.localPoolVarUint8.setReadWriteMode(pool_rwm_t::VAR_WRITE);
-    localSet.localPoolUint16Vec.setReadWriteMode(pool_rwm_t::VAR_WRITE);
-    CHECK(sharedSet.registerVariable(&localSet.localPoolVarUint8) == returnvalue::OK);
-    CHECK(sharedSet.registerVariable(&localSet.localPoolUint16Vec) == returnvalue::OK);
-    CHECK(sharedSet.initialize() == returnvalue::OK);
-    CHECK(sharedSet.lockDataset() == returnvalue::OK);
-    CHECK(sharedSet.unlockDataset() == returnvalue::OK);
-
-    {
-      // PoolReadGuard rg(&sharedSet);
-      // CHECK(rg.getReadResult() == returnvalue::OK);
-      localSet.localPoolVarUint8.value = 5;
-      localSet.localPoolUint16Vec.value[0] = 1;
-      localSet.localPoolUint16Vec.value[1] = 2;
-      localSet.localPoolUint16Vec.value[2] = 3;
-      CHECK(sharedSet.commit() == returnvalue::OK);
-    }
-
-    sharedSet.setReadCommitProtectionBehaviour(true);
-  }
-}
diff --git a/unittests/datapoollocal/testLocalPoolManager.cpp b/unittests/datapoollocal/testLocalPoolManager.cpp
deleted file mode 100644
index 31d2f876..00000000
--- a/unittests/datapoollocal/testLocalPoolManager.cpp
+++ /dev/null
@@ -1,393 +0,0 @@
-#include <fsfw/datapool/PoolReadGuard.h>
-#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
-#include <fsfw/datapoollocal/StaticLocalDataSet.h>
-#include <fsfw/globalfunctions/timevalOperations.h>
-#include <fsfw/housekeeping/HousekeepingSnapshot.h>
-#include <fsfw/ipc/CommandMessageCleaner.h>
-#include <fsfw/objectmanager/ObjectManager.h>
-#include <fsfw/timemanager/CCSDSTime.h>
-
-#include <catch2/catch_approx.hpp>
-#include <catch2/catch_test_macros.hpp>
-#include <catch2/matchers/catch_matchers_floating_point.hpp>
-#include <iostream>
-
-#include "CatchDefinitions.h"
-#include "mocks/HkReceiverMock.h"
-#include "mocks/LocalPoolOwnerBase.h"
-
-TEST_CASE("Local Pool Manager Tests", "[LocManTest]") {
-  const MessageQueueId_t defaultDestId = 1;
-  const MessageQueueId_t hkDest = defaultDestId;
-  const MessageQueueId_t subscriberId = 2;
-  auto hkReceiver = HkReceiverMock(hkDest);
-  auto queue = MessageQueueMock(3);
-  LocalPoolOwnerBase poolOwner(queue, objects::TEST_LOCAL_POOL_OWNER_BASE);
-  REQUIRE(poolOwner.initializeHkManager() == returnvalue::OK);
-  REQUIRE(poolOwner.initializeHkManagerAfterTaskCreation() == returnvalue::OK);
-
-  MessageQueueMock& poolOwnerMock = poolOwner.getMockQueueHandle();
-
-  // TODO: This is ugly. This should be an arbitrary ctor argument. Fix this in the pool
-  //       manager
-  poolOwnerMock.setDefaultDestination(defaultDestId);
-  poolOwner.setHkDestId(hkDest);
-
-  auto* hkMan = poolOwner.getHkManagerHandle();
-
-  CommandMessage messageSent;
-
-  SECTION("Basic Test") {
-    {
-      /* For code coverage, should not crash */
-      LocalDataPoolManager manager(nullptr, nullptr);
-    }
-    auto owner = poolOwner.poolManager.getOwner();
-    REQUIRE(owner != nullptr);
-    CHECK(owner->getObjectId() == objects::TEST_LOCAL_POOL_OWNER_BASE);
-
-    /* Subscribe for message generation on update. */
-    REQUIRE(poolOwner.subscribeWrapperSetUpdate(subscriberId) == returnvalue::OK);
-    /* Subscribe for an update message. */
-    poolOwner.dataset.setChanged(true);
-    /* Now the update message should be generated. */
-    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
-    REQUIRE(poolOwnerMock.wasMessageSent());
-
-    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::OK);
-    CHECK(messageSent.getCommand() ==
-          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));
-
-    /* Should have been reset. */
-    CHECK(poolOwner.dataset.hasChanged() == false);
-    poolOwnerMock.clearMessages(true);
-    /* Set changed again, result should be the same. */
-    poolOwner.dataset.setChanged(true);
-    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
-
-    REQUIRE(poolOwnerMock.wasMessageSent() == true);
-    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
-    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::OK);
-    CHECK(messageSent.getCommand() ==
-          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));
-
-    poolOwnerMock.clearMessages(true);
-    /* Now subscribe for set update HK as well. */
-    REQUIRE(poolOwner.subscribeWrapperSetUpdateHk(false, &hkReceiver) == returnvalue::OK);
-    poolOwner.dataset.setChanged(true);
-    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
-    REQUIRE(poolOwnerMock.wasMessageSent() == true);
-    CHECK(poolOwnerMock.numberOfSentMessages() == 2);
-    // first message sent should be the update notification
-    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::OK);
-    CHECK(messageSent.getCommand() ==
-          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));
-    REQUIRE(poolOwnerMock.getNextSentMessageToDefaultDest(messageSent) == returnvalue::OK);
-    CHECK(messageSent.getCommand() == static_cast<int>(HousekeepingMessage::HK_REPORT));
-    /* Clear message to avoid memory leak, our mock won't do it for us (yet) */
-    CommandMessageCleaner::clearCommandMessage(&messageSent);
-  }
-
-  SECTION("SetSnapshotUpdateTest") {
-    /* Set the variables in the set to certain values. These are checked later. */
-    {
-      PoolReadGuard readHelper(&poolOwner.dataset);
-      REQUIRE(readHelper.getReadResult() == returnvalue::OK);
-      poolOwner.dataset.localPoolVarUint8.value = 5;
-      poolOwner.dataset.localPoolVarFloat.value = -12.242;
-      poolOwner.dataset.localPoolUint16Vec.value[0] = 2;
-      poolOwner.dataset.localPoolUint16Vec.value[1] = 32;
-      poolOwner.dataset.localPoolUint16Vec.value[2] = 42932;
-    }
-
-    /* Subscribe for snapshot generation on update. */
-    REQUIRE(poolOwner.subscribeWrapperSetUpdateSnapshot(subscriberId) == returnvalue::OK);
-    poolOwner.dataset.setChanged(true);
-
-    /* Store current time, we are going to check the (approximate) time equality later */
-    timeval now{};
-    Clock::getClock_timeval(&now);
-
-    /* Trigger generation of snapshot */
-    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
-    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::OK);
-    /* Check that snapshot was generated */
-    CHECK(messageSent.getCommand() == static_cast<int>(HousekeepingMessage::UPDATE_SNAPSHOT_SET));
-    /* Now we deserialize the snapshot into a new dataset instance */
-    CCSDSTime::CDS_short cdsShort{};
-    LocalPoolTestDataSet newSet;
-    HousekeepingSnapshot snapshot(&cdsShort, &newSet);
-    store_address_t storeId;
-    HousekeepingMessage::getUpdateSnapshotSetCommand(&messageSent, &storeId);
-    ConstAccessorPair accessorPair = tglob::getIpcStoreHandle()->getData(storeId);
-    REQUIRE(accessorPair.first == returnvalue::OK);
-    const uint8_t* readOnlyPtr = accessorPair.second.data();
-    size_t sizeToDeserialize = accessorPair.second.size();
-    CHECK(newSet.localPoolVarFloat.value == 0);
-    CHECK(newSet.localPoolVarUint8 == 0);
-    CHECK(newSet.localPoolUint16Vec.value[0] == 0);
-    CHECK(newSet.localPoolUint16Vec.value[1] == 0);
-    CHECK(newSet.localPoolUint16Vec.value[2] == 0);
-    /* Fill the dataset and timestamp */
-    REQUIRE(snapshot.deSerialize(&readOnlyPtr, &sizeToDeserialize,
-                                 SerializeIF::Endianness::MACHINE) == returnvalue::OK);
-    /* Now we check that the snapshot is actually correct */
-    CHECK(newSet.localPoolVarFloat.value == Catch::Approx(-12.242));
-    CHECK(newSet.localPoolVarUint8 == 5);
-    CHECK(newSet.localPoolUint16Vec.value[0] == 2);
-    CHECK(newSet.localPoolUint16Vec.value[1] == 32);
-    CHECK(newSet.localPoolUint16Vec.value[2] == 42932);
-
-    /* Now we check that both times are equal */
-    timeval timeFromHK{};
-    auto result = CCSDSTime::convertFromCDS(&timeFromHK, &cdsShort);
-    CHECK(result == returnvalue::OK);
-    timeval difference = timeFromHK - now;
-    CHECK(timevalOperations::toDouble(difference) < 1.0);
-  }
-
-  SECTION("VariableSnapshotTest") {
-    /* Acquire subscription interface */
-    ProvidesDataPoolSubscriptionIF* subscriptionIF = poolOwner.getSubscriptionInterface();
-    REQUIRE(subscriptionIF != nullptr);
-
-    /* Subscribe for variable snapshot */
-    REQUIRE(poolOwner.subscribeWrapperVariableSnapshot(subscriberId, lpool::uint8VarId) ==
-            returnvalue::OK);
-    auto poolVar =
-        dynamic_cast<lp_var_t<uint8_t>*>(poolOwner.getPoolObjectHandle(lpool::uint8VarId));
-    REQUIRE(poolVar != nullptr);
-
-    {
-      PoolReadGuard rg(poolVar);
-      CHECK(rg.getReadResult() == returnvalue::OK);
-      poolVar->value = 25;
-    }
-
-    poolVar->setChanged(true);
-    /* Store current time, we are going to check the (approximate) time equality later */
-    CCSDSTime::CDS_short timeCdsNow{};
-    timeval now{};
-    Clock::getClock_timeval(&now);
-    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
-
-    /* Check update snapshot was sent. */
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
-
-    /* Should have been reset. */
-    CHECK(poolVar->hasChanged() == false);
-    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::OK);
-    CHECK(messageSent.getCommand() ==
-          static_cast<int>(HousekeepingMessage::UPDATE_SNAPSHOT_VARIABLE));
-    /* Now we deserialize the snapshot into a new dataset instance */
-    CCSDSTime::CDS_short cdsShort{};
-    lp_var_t<uint8_t> varCopy = lp_var_t<uint8_t>(lpool::uint8VarGpid);
-    HousekeepingSnapshot snapshot(&cdsShort, &varCopy);
-    store_address_t storeId;
-    HousekeepingMessage::getUpdateSnapshotVariableCommand(&messageSent, &storeId);
-    ConstAccessorPair accessorPair = tglob::getIpcStoreHandle()->getData(storeId);
-    REQUIRE(accessorPair.first == returnvalue::OK);
-    const uint8_t* readOnlyPtr = accessorPair.second.data();
-    size_t sizeToDeserialize = accessorPair.second.size();
-    CHECK(varCopy.value == 0);
-    /* Fill the dataset and timestamp */
-    REQUIRE(snapshot.deSerialize(&readOnlyPtr, &sizeToDeserialize,
-                                 SerializeIF::Endianness::MACHINE) == returnvalue::OK);
-    CHECK(varCopy.value == 25);
-
-    /* Now we check that both times are equal */
-    timeval timeFromHK{};
-    auto result = CCSDSTime::convertFromCDS(&timeFromHK, &cdsShort);
-    CHECK(result == returnvalue::OK);
-    timeval difference = timeFromHK - now;
-    CHECK(timevalOperations::toDouble(difference) < 1.0);
-  }
-
-  SECTION("VariableNotificationTest") {
-    /* Acquire subscription interface */
-    ProvidesDataPoolSubscriptionIF* subscriptionIF = poolOwner.getSubscriptionInterface();
-    REQUIRE(subscriptionIF != nullptr);
-
-    /* Subscribe for variable update */
-    REQUIRE(poolOwner.subscribeWrapperVariableUpdate(subscriberId, lpool::uint8VarId) ==
-            returnvalue::OK);
-    auto* poolVar =
-        dynamic_cast<lp_var_t<uint8_t>*>(poolOwner.getPoolObjectHandle(lpool::uint8VarId));
-    REQUIRE(poolVar != nullptr);
-    poolVar->setChanged(true);
-    REQUIRE(poolVar->hasChanged() == true);
-    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
-
-    /* Check update notification was sent. */
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
-    /* Should have been reset. */
-    CHECK(poolVar->hasChanged() == false);
-    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::OK);
-    CHECK(messageSent.getCommand() ==
-          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
-    /* Now subscribe for the dataset update (HK and update) again with subscription interface */
-    REQUIRE(subscriptionIF->subscribeForSetUpdateMessage(lpool::testSetId, objects::NO_OBJECT,
-                                                         subscriberId, false) == returnvalue::OK);
-    REQUIRE(poolOwner.subscribeWrapperSetUpdateHk(false, &hkReceiver) == returnvalue::OK);
-
-    poolOwner.dataset.setChanged(true);
-    poolOwnerMock.clearMessages();
-    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
-    /* Now two messages should be sent. */
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    CHECK(poolOwnerMock.numberOfSentMessages() == 2);
-    poolOwnerMock.clearMessages(true);
-
-    poolOwner.dataset.setChanged(true);
-    poolOwnerMock.clearMessages(true);
-    poolVar->setChanged(true);
-    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
-    /* Now three messages should be sent. */
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    CHECK(poolOwnerMock.numberOfSentMessages() == 3);
-    CHECK(poolOwnerMock.numberOfSentMessagesToDest(subscriberId) == 2);
-    CHECK(poolOwnerMock.numberOfSentMessagesToDest(hkDest) == 1);
-    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::OK);
-    CHECK(messageSent.getCommand() ==
-          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_VARIABLE));
-    REQUIRE(poolOwnerMock.clearLastSentMessage(subscriberId) == returnvalue::OK);
-    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == returnvalue::OK);
-    CHECK(messageSent.getCommand() ==
-          static_cast<int>(HousekeepingMessage::UPDATE_NOTIFICATION_SET));
-    REQUIRE(poolOwnerMock.clearLastSentMessage(subscriberId) == returnvalue::OK);
-    REQUIRE(poolOwnerMock.getNextSentMessageToDefaultDest(messageSent) == returnvalue::OK);
-    CHECK(messageSent.getCommand() == static_cast<int>(HousekeepingMessage::HK_REPORT));
-    REQUIRE(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
-    REQUIRE(poolOwnerMock.getNextSentMessage(subscriberId, messageSent) == MessageQueueIF::EMPTY);
-    REQUIRE(poolOwnerMock.getNextSentMessageToDefaultDest(messageSent) == MessageQueueIF::EMPTY);
-  }
-
-  SECTION("PeriodicHKAndMessaging") {
-    /* Now we subcribe for a HK periodic generation. Even when it's difficult to simulate
-    the temporal behaviour correctly the HK manager should generate a HK packet
-    immediately and the periodic helper depends on HK op function calls anyway instead of
-    using the clock, so we could also just call performHkOperation multiple times */
-    REQUIRE(poolOwner.subscribePeriodicHk(true) == returnvalue::OK);
-    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
-    /* Now HK packet should be sent as message immediately. */
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
-    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
-
-    LocalPoolDataSetBase* setHandle = poolOwner.getDataSetHandle(lpool::testSid);
-    REQUIRE(setHandle != nullptr);
-    CHECK(poolOwner.poolManager.generateHousekeepingPacket(lpool::testSid, setHandle, false) ==
-          returnvalue::OK);
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
-    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
-
-    CHECK(setHandle->getReportingEnabled() == true);
-    CommandMessage hkCmd;
-    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false);
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    CHECK(setHandle->getReportingEnabled() == false);
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    CHECK(poolOwnerMock.numberOfSentMessages() == 1);
-    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
-
-    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, true);
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    CHECK(setHandle->getReportingEnabled() == true);
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
-
-    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false);
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    CHECK(setHandle->getReportingEnabled() == false);
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
-
-    HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd, lpool::testSid, 0.4);
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    CHECK_THAT(poolOwner.dataset.getCollectionInterval(), Catch::Matchers::WithinAbs(0.4, 0.01));
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
-    CHECK(poolOwnerMock.clearLastSentMessage() == returnvalue::OK);
-
-    HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid);
-    REQUIRE(poolOwner.poolManager.performHkOperation() == returnvalue::OK);
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    /* Now HK packet should be sent as message. */
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
-    poolOwnerMock.clearMessages();
-
-    HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid);
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
-    poolOwnerMock.clearMessages();
-
-    HousekeepingMessage::setUpdateNotificationSetCommand(&hkCmd, lpool::testSid);
-    sid_t sidToCheck;
-    store_address_t storeId;
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    CHECK(poolOwner.changedDataSetCallbackWasCalled(sidToCheck, storeId) == true);
-    CHECK(sidToCheck == lpool::testSid);
-
-    HousekeepingMessage::setStructureReportingCommand(&hkCmd, lpool::testSid);
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
-    poolOwnerMock.clearMessages();
-
-    HousekeepingMessage::setCollectionIntervalModificationCommand(&hkCmd, lpool::testSid, 0.4);
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
-    poolOwnerMock.clearMessages();
-
-    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, true);
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
-    poolOwnerMock.clearMessages();
-
-    HousekeepingMessage::setToggleReportingCommand(&hkCmd, lpool::testSid, false);
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
-    poolOwnerMock.clearMessages();
-
-    HousekeepingMessage::setOneShotReportCommand(&hkCmd, lpool::testSid);
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    REQUIRE(poolOwnerMock.wasMessageSent());
-    REQUIRE(poolOwnerMock.numberOfSentMessages() == 1);
-    poolOwnerMock.clearMessages();
-
-    HousekeepingMessage::setUpdateNotificationVariableCommand(&hkCmd, lpool::uint8VarGpid);
-    gp_id_t gpidToCheck;
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    CHECK(poolOwner.changedVariableCallbackWasCalled(gpidToCheck, storeId) == true);
-    CHECK(gpidToCheck == lpool::uint8VarGpid);
-
-    HousekeepingMessage::setUpdateSnapshotSetCommand(&hkCmd, lpool::testSid,
-                                                     store_address_t::invalid());
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    CHECK(poolOwner.changedDataSetCallbackWasCalled(sidToCheck, storeId) == true);
-    CHECK(sidToCheck == lpool::testSid);
-
-    HousekeepingMessage::setUpdateSnapshotVariableCommand(&hkCmd, lpool::uint8VarGpid,
-                                                          store_address_t::invalid());
-    CHECK(poolOwner.poolManager.handleHousekeepingMessage(&hkCmd) == returnvalue::OK);
-    CHECK(poolOwner.changedVariableCallbackWasCalled(gpidToCheck, storeId) == true);
-    CHECK(gpidToCheck == lpool::uint8VarGpid);
-
-    poolOwner.poolManager.printPoolEntry(lpool::uint8VarId);
-  }
-
-  /* we need to reset the subscription list because the pool owner
-  is a global object. */
-  CHECK(poolOwner.reset() == returnvalue::OK);
-  poolOwnerMock.clearMessages(true);
-}
diff --git a/unittests/devicehandler/TestDeviceHandlerBase.cpp b/unittests/devicehandler/TestDeviceHandlerBase.cpp
index 67c3cdaf..d3f8a55f 100644
--- a/unittests/devicehandler/TestDeviceHandlerBase.cpp
+++ b/unittests/devicehandler/TestDeviceHandlerBase.cpp
@@ -1,19 +1,26 @@
+#include <mock/HkReceiverMock.h>
+#include <mock/MessageQueueMock.h>
+
 #include <catch2/catch_test_macros.hpp>
 
 #include "DeviceHandlerCommander.h"
-#include "mocks/ComIFMock.h"
-#include "mocks/CookieIFMock.h"
-#include "mocks/DeviceFdirMock.h"
-#include "mocks/DeviceHandlerMock.h"
+#include "mock/ComIFMock.h"
+#include "mock/CookieIFMock.h"
+#include "mock/DeviceFdirMock.h"
+#include "mock/DeviceHandlerMock.h"
 #include "objects/systemObjectList.h"
 
 TEST_CASE("Device Handler Base", "[DeviceHandlerBase]") {
   // Will be deleted with DHB destructor
   auto* cookieIFMock = new CookieIFMock;
   ComIFMock comIF(objects::COM_IF_MOCK);
+  MessageQueueMock mqMock(1, MessageQueueIF::NO_QUEUE);
+  HkReceiverMock hkReceiver(1);
   DeviceFdirMock deviceFdirMock(objects::DEVICE_HANDLER_MOCK, objects::NO_OBJECT);
   DeviceHandlerMock deviceHandlerMock(objects::DEVICE_HANDLER_MOCK, objects::COM_IF_MOCK,
                                       cookieIFMock, &deviceFdirMock);
+  auto& hkHelper = deviceHandlerMock.getHkHelper();
+  hkHelper.setHkDestinationId(1);
   ReturnValue_t result = deviceHandlerMock.initialize();
   REQUIRE(result == returnvalue::OK);
   DeviceHandlerCommander deviceHandlerCommander(objects::DEVICE_HANDLER_COMMANDER);
diff --git a/unittests/hal/testFsMock.cpp b/unittests/hal/testFsMock.cpp
index ac69441a..2f1caeb5 100644
--- a/unittests/hal/testFsMock.cpp
+++ b/unittests/hal/testFsMock.cpp
@@ -1,7 +1,7 @@
 #include <catch2/catch_test_macros.hpp>
 
 #include "fsfw/serialize/SerializeIF.h"
-#include "mocks/FilesystemMock.h"
+#include "mock/FilesystemMock.h"
 
 using namespace std;
 
diff --git a/unittests/internalerror/TestInternalErrorReporter.cpp b/unittests/internalerror/TestInternalErrorReporter.cpp
index 5b7db407..45e8867b 100644
--- a/unittests/internalerror/TestInternalErrorReporter.cpp
+++ b/unittests/internalerror/TestInternalErrorReporter.cpp
@@ -13,7 +13,7 @@
 #include "fsfw/ipc/CommandMessage.h"
 #include "fsfw/ipc/MessageQueueMessage.h"
 #include "fsfw/objectmanager/frameworkObjects.h"
-#include "mocks/PeriodicTaskIFMock.h"
+#include "mock/PeriodicTaskIFMock.h"
 
 TEST_CASE("Internal Error Reporter", "[TestInternalError]") {
   PeriodicTaskMock task(10, nullptr);
@@ -31,8 +31,8 @@ TEST_CASE("Internal Error Reporter", "[TestInternalError]") {
   task.startTask();
   MessageQueueIF* testQueue = QueueFactory::instance()->createMessageQueue(1);
   MessageQueueIF* hkQueue = QueueFactory::instance()->createMessageQueue(1);
-  internalErrorReporter->getSubscriptionInterface()->subscribeForSetUpdateMessage(
-      InternalErrorDataset::ERROR_SET_ID, objects::NO_OBJECT, hkQueue->getId(), true);
+  // internalErrorReporter->getSubscriptionInterface()->subscribeForSetUpdateMessage(
+  // InternalErrorDataset::ERROR_SET_ID, objects::NO_OBJECT, hkQueue->getId(), true);
   auto* ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
   SECTION("MessageQueueFull") {
     CommandMessage message;
@@ -46,6 +46,8 @@ TEST_CASE("Internal Error Reporter", "[TestInternalError]") {
      then remeber the queueHit count and force another hit */
     internalErrorReporter->queueMessageNotSent();
     internalErrorReporter->performOperation(0);
+    // TODO: Fix test
+    /*
     {
       CommandMessage hkMessage;
       result = hkQueue->receiveMessage(&hkMessage);
@@ -114,6 +116,7 @@ TEST_CASE("Internal Error Reporter", "[TestInternalError]") {
       REQUIRE(result == returnvalue::OK);
       internalErrorReporter->performOperation(0);
     }
+     */
   }
   QueueFactory::instance()->deleteMessageQueue(testQueue);
   QueueFactory::instance()->deleteMessageQueue(hkQueue);
diff --git a/unittests/mocks/AcceptsTcMock.cpp b/unittests/mock/AcceptsTcMock.cpp
similarity index 100%
rename from unittests/mocks/AcceptsTcMock.cpp
rename to unittests/mock/AcceptsTcMock.cpp
diff --git a/unittests/mocks/AcceptsTcMock.h b/unittests/mock/AcceptsTcMock.h
similarity index 100%
rename from unittests/mocks/AcceptsTcMock.h
rename to unittests/mock/AcceptsTcMock.h
diff --git a/unittests/mocks/AcceptsTmMock.cpp b/unittests/mock/AcceptsTmMock.cpp
similarity index 100%
rename from unittests/mocks/AcceptsTmMock.cpp
rename to unittests/mock/AcceptsTmMock.cpp
diff --git a/unittests/mocks/AcceptsTmMock.h b/unittests/mock/AcceptsTmMock.h
similarity index 100%
rename from unittests/mocks/AcceptsTmMock.h
rename to unittests/mock/AcceptsTmMock.h
diff --git a/unittests/mocks/CMakeLists.txt b/unittests/mock/CMakeLists.txt
similarity index 94%
rename from unittests/mocks/CMakeLists.txt
rename to unittests/mock/CMakeLists.txt
index bd093da8..89023b0d 100644
--- a/unittests/mocks/CMakeLists.txt
+++ b/unittests/mock/CMakeLists.txt
@@ -7,7 +7,6 @@ target_sources(
           ComIFMock.cpp
           MessageQueueMock.cpp
           InternalErrorReporterMock.cpp
-          LocalPoolOwnerBase.cpp
           PusVerificationReporterMock.cpp
           PusServiceBaseMock.cpp
           AcceptsTmMock.cpp
@@ -16,6 +15,7 @@ target_sources(
           AcceptsTcMock.cpp
           StorageManagerMock.cpp
           FilesystemMock.cpp
+          TestPoolOwner.cpp
           EventReportingProxyMock.cpp)
 
 add_subdirectory(cfdp)
diff --git a/unittests/mocks/CcsdsCheckerMock.cpp b/unittests/mock/CcsdsCheckerMock.cpp
similarity index 100%
rename from unittests/mocks/CcsdsCheckerMock.cpp
rename to unittests/mock/CcsdsCheckerMock.cpp
diff --git a/unittests/mocks/CcsdsCheckerMock.h b/unittests/mock/CcsdsCheckerMock.h
similarity index 100%
rename from unittests/mocks/CcsdsCheckerMock.h
rename to unittests/mock/CcsdsCheckerMock.h
diff --git a/unittests/mocks/CdsShortTimestamperMock.h b/unittests/mock/CdsShortTimestamperMock.h
similarity index 100%
rename from unittests/mocks/CdsShortTimestamperMock.h
rename to unittests/mock/CdsShortTimestamperMock.h
diff --git a/unittests/mocks/ComIFMock.cpp b/unittests/mock/ComIFMock.cpp
similarity index 100%
rename from unittests/mocks/ComIFMock.cpp
rename to unittests/mock/ComIFMock.cpp
diff --git a/unittests/mocks/ComIFMock.h b/unittests/mock/ComIFMock.h
similarity index 100%
rename from unittests/mocks/ComIFMock.h
rename to unittests/mock/ComIFMock.h
diff --git a/unittests/mocks/CookieIFMock.cpp b/unittests/mock/CookieIFMock.cpp
similarity index 100%
rename from unittests/mocks/CookieIFMock.cpp
rename to unittests/mock/CookieIFMock.cpp
diff --git a/unittests/mocks/CookieIFMock.h b/unittests/mock/CookieIFMock.h
similarity index 100%
rename from unittests/mocks/CookieIFMock.h
rename to unittests/mock/CookieIFMock.h
diff --git a/unittests/mocks/DeviceFdirMock.cpp b/unittests/mock/DeviceFdirMock.cpp
similarity index 100%
rename from unittests/mocks/DeviceFdirMock.cpp
rename to unittests/mock/DeviceFdirMock.cpp
diff --git a/unittests/mocks/DeviceFdirMock.h b/unittests/mock/DeviceFdirMock.h
similarity index 100%
rename from unittests/mocks/DeviceFdirMock.h
rename to unittests/mock/DeviceFdirMock.h
diff --git a/unittests/mocks/DeviceHandlerMock.cpp b/unittests/mock/DeviceHandlerMock.cpp
similarity index 87%
rename from unittests/mocks/DeviceHandlerMock.cpp
rename to unittests/mock/DeviceHandlerMock.cpp
index 1242d010..bb8b748c 100644
--- a/unittests/mocks/DeviceHandlerMock.cpp
+++ b/unittests/mock/DeviceHandlerMock.cpp
@@ -90,7 +90,7 @@ void DeviceHandlerMock::changeSimpleCommandReplyCountdown(uint32_t timeout) {
 
 void DeviceHandlerMock::resetPeriodicReplyState() { periodicReplyReceived = false; }
 
-bool DeviceHandlerMock::getPeriodicReplyReceived() { return periodicReplyReceived; }
+bool DeviceHandlerMock::getPeriodicReplyReceived() const { return periodicReplyReceived; }
 
 ReturnValue_t DeviceHandlerMock::enablePeriodicReply(DeviceCommandId_t replyId) {
   return updatePeriodicReply(true, replyId);
@@ -108,3 +108,14 @@ ReturnValue_t DeviceHandlerMock::initialize() {
   setMode(MODE_ON);
   return result;
 }
+
+ReturnValue_t DeviceHandlerMock::serializeHkDataset(dp::structure_id_t structureId, uint8_t *buf,
+                                                    size_t maxSize) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t DeviceHandlerMock::specifyHkDatasets(std::vector<hk::SetSpecification> &setList) {
+  return returnvalue::OK;
+}
+
+dp::SharedPool *DeviceHandlerMock::getOptionalSharedPool() { return nullptr; }
diff --git a/unittests/mocks/DeviceHandlerMock.h b/unittests/mock/DeviceHandlerMock.h
similarity index 73%
rename from unittests/mocks/DeviceHandlerMock.h
rename to unittests/mock/DeviceHandlerMock.h
index b659857b..23690687 100644
--- a/unittests/mocks/DeviceHandlerMock.h
+++ b/unittests/mock/DeviceHandlerMock.h
@@ -5,24 +5,31 @@
 
 class DeviceHandlerMock : public DeviceHandlerBase {
  public:
-  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
-  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+  static constexpr DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static constexpr DeviceCommandId_t PERIODIC_REPLY = 2;
 
-  static const uint8_t SIMPLE_COMMAND_DATA = 1;
-  static const uint8_t PERIODIC_REPLY_DATA = 2;
+  static constexpr uint8_t SIMPLE_COMMAND_DATA = 1;
+  static constexpr uint8_t PERIODIC_REPLY_DATA = 2;
 
   DeviceHandlerMock(object_id_t objectId, object_id_t deviceCommunication, CookieIF *comCookie,
                     FailureIsolationBase *fdirInstance);
-  virtual ~DeviceHandlerMock();
+  ~DeviceHandlerMock() override;
   void changePeriodicReplyCountdown(uint32_t timeout);
   void changeSimpleCommandReplyCountdown(uint32_t timeout);
   void resetPeriodicReplyState();
-  bool getPeriodicReplyReceived();
+  bool getPeriodicReplyReceived() const;
   ReturnValue_t enablePeriodicReply(DeviceCommandId_t replyId);
   ReturnValue_t disablePeriodicReply(DeviceCommandId_t replyId);
 
   ReturnValue_t initialize() override;
 
+  ReturnValue_t serializeHkDataset(dp::structure_id_t structureId, uint8_t *buf,
+                                   size_t maxSize) override;
+
+  ReturnValue_t specifyHkDatasets(std::vector<hk::SetSpecification> &setList) override;
+
+  dp::SharedPool *getOptionalSharedPool() override;
+
  protected:
   void doStartUp() override;
   void doShutDown() override;
@@ -40,7 +47,7 @@ class DeviceHandlerMock : public DeviceHandlerBase {
   Countdown simpleCommandReplyTimeout = Countdown(1000);
   Countdown periodicReplyCountdown = Countdown(1000);
 
-  uint8_t commandBuffer[1];
+  uint8_t commandBuffer[1]{};
 
   bool periodicReplyReceived = false;
 };
diff --git a/unittests/mocks/EventReportingProxyMock.cpp b/unittests/mock/EventReportingProxyMock.cpp
similarity index 100%
rename from unittests/mocks/EventReportingProxyMock.cpp
rename to unittests/mock/EventReportingProxyMock.cpp
diff --git a/unittests/mocks/EventReportingProxyMock.h b/unittests/mock/EventReportingProxyMock.h
similarity index 100%
rename from unittests/mocks/EventReportingProxyMock.h
rename to unittests/mock/EventReportingProxyMock.h
diff --git a/unittests/mocks/FilesystemMock.cpp b/unittests/mock/FilesystemMock.cpp
similarity index 100%
rename from unittests/mocks/FilesystemMock.cpp
rename to unittests/mock/FilesystemMock.cpp
diff --git a/unittests/mocks/FilesystemMock.h b/unittests/mock/FilesystemMock.h
similarity index 100%
rename from unittests/mocks/FilesystemMock.h
rename to unittests/mock/FilesystemMock.h
diff --git a/unittests/mocks/HkReceiverMock.h b/unittests/mock/HkReceiverMock.h
similarity index 100%
rename from unittests/mocks/HkReceiverMock.h
rename to unittests/mock/HkReceiverMock.h
diff --git a/unittests/mocks/InternalErrorReporterMock.cpp b/unittests/mock/InternalErrorReporterMock.cpp
similarity index 100%
rename from unittests/mocks/InternalErrorReporterMock.cpp
rename to unittests/mock/InternalErrorReporterMock.cpp
diff --git a/unittests/mocks/InternalErrorReporterMock.h b/unittests/mock/InternalErrorReporterMock.h
similarity index 100%
rename from unittests/mocks/InternalErrorReporterMock.h
rename to unittests/mock/InternalErrorReporterMock.h
diff --git a/unittests/mocks/MessageQueueMock.cpp b/unittests/mock/MessageQueueMock.cpp
similarity index 97%
rename from unittests/mocks/MessageQueueMock.cpp
rename to unittests/mock/MessageQueueMock.cpp
index 96a6ee86..a0ba9279 100644
--- a/unittests/mocks/MessageQueueMock.cpp
+++ b/unittests/mock/MessageQueueMock.cpp
@@ -3,8 +3,8 @@
 #include <algorithm>
 #include <stdexcept>
 
-MessageQueueMock::MessageQueueMock(MessageQueueId_t queueId)
-    : MessageQueueBase(queueId, MessageQueueIF::NO_QUEUE, nullptr) {}
+MessageQueueMock::MessageQueueMock(MessageQueueId_t queueId, MessageQueueId_t defaultDest)
+    : MessageQueueBase(queueId, defaultDest, nullptr) {}
 
 bool MessageQueueMock::wasMessageSent() const {
   return std::any_of(
diff --git a/unittests/mocks/MessageQueueMock.h b/unittests/mock/MessageQueueMock.h
similarity index 96%
rename from unittests/mocks/MessageQueueMock.h
rename to unittests/mock/MessageQueueMock.h
index cacb72e4..26ac9470 100644
--- a/unittests/mocks/MessageQueueMock.h
+++ b/unittests/mock/MessageQueueMock.h
@@ -23,7 +23,7 @@ struct SendInfo {
 class MessageQueueMock : public MessageQueueBase {
  public:
   void addReceivedMessage(MessageQueueMessageIF& msg);
-  explicit MessageQueueMock(MessageQueueId_t queueId);
+  explicit MessageQueueMock(MessageQueueId_t queueId, MessageQueueId_t defaultDest);
 
   //! Get next message which was sent to the default destination
   ReturnValue_t getNextSentMessageToDefaultDest(MessageQueueMessageIF& message);
diff --git a/unittests/mocks/PeriodicTaskIFMock.h b/unittests/mock/PeriodicTaskIFMock.h
similarity index 100%
rename from unittests/mocks/PeriodicTaskIFMock.h
rename to unittests/mock/PeriodicTaskIFMock.h
diff --git a/unittests/mocks/PowerSwitcherMock.cpp b/unittests/mock/PowerSwitcherMock.cpp
similarity index 100%
rename from unittests/mocks/PowerSwitcherMock.cpp
rename to unittests/mock/PowerSwitcherMock.cpp
diff --git a/unittests/mocks/PowerSwitcherMock.h b/unittests/mock/PowerSwitcherMock.h
similarity index 100%
rename from unittests/mocks/PowerSwitcherMock.h
rename to unittests/mock/PowerSwitcherMock.h
diff --git a/unittests/mocks/PusDistributorMock.cpp b/unittests/mock/PusDistributorMock.cpp
similarity index 100%
rename from unittests/mocks/PusDistributorMock.cpp
rename to unittests/mock/PusDistributorMock.cpp
diff --git a/unittests/mocks/PusDistributorMock.h b/unittests/mock/PusDistributorMock.h
similarity index 100%
rename from unittests/mocks/PusDistributorMock.h
rename to unittests/mock/PusDistributorMock.h
diff --git a/unittests/mocks/PusServiceBaseMock.cpp b/unittests/mock/PusServiceBaseMock.cpp
similarity index 100%
rename from unittests/mocks/PusServiceBaseMock.cpp
rename to unittests/mock/PusServiceBaseMock.cpp
diff --git a/unittests/mocks/PusServiceBaseMock.h b/unittests/mock/PusServiceBaseMock.h
similarity index 100%
rename from unittests/mocks/PusServiceBaseMock.h
rename to unittests/mock/PusServiceBaseMock.h
diff --git a/unittests/mocks/PusVerificationReporterMock.cpp b/unittests/mock/PusVerificationReporterMock.cpp
similarity index 100%
rename from unittests/mocks/PusVerificationReporterMock.cpp
rename to unittests/mock/PusVerificationReporterMock.cpp
diff --git a/unittests/mocks/PusVerificationReporterMock.h b/unittests/mock/PusVerificationReporterMock.h
similarity index 100%
rename from unittests/mocks/PusVerificationReporterMock.h
rename to unittests/mock/PusVerificationReporterMock.h
diff --git a/unittests/mocks/SimpleSerializable.h b/unittests/mock/SimpleSerializable.h
similarity index 100%
rename from unittests/mocks/SimpleSerializable.h
rename to unittests/mock/SimpleSerializable.h
diff --git a/unittests/mocks/StorageManagerMock.cpp b/unittests/mock/StorageManagerMock.cpp
similarity index 100%
rename from unittests/mocks/StorageManagerMock.cpp
rename to unittests/mock/StorageManagerMock.cpp
diff --git a/unittests/mocks/StorageManagerMock.h b/unittests/mock/StorageManagerMock.h
similarity index 100%
rename from unittests/mocks/StorageManagerMock.h
rename to unittests/mock/StorageManagerMock.h
diff --git a/unittests/mock/TestPoolOwner.cpp b/unittests/mock/TestPoolOwner.cpp
new file mode 100644
index 00000000..804fad4d
--- /dev/null
+++ b/unittests/mock/TestPoolOwner.cpp
@@ -0,0 +1,90 @@
+#include "TestPoolOwner.h"
+
+#include <fsfw/datapool/PoolReadGuard.h>
+
+using namespace lpool;
+
+TestPoolOwner::TestPoolOwner(MessageQueueIF &queue, MessageQueueId_t hkDestId, object_id_t objectId)
+    : SystemObject(objectId),
+      hkHelper(this, &queue, hkDestId),
+      sharedPool(TestPoolOwner::getObjectId()),
+      set1(sharedPool, lpool::testSetId1),
+      set2(sharedPool, lpool::testSetId2),
+      queue(queue) {}
+
+TestPoolOwner::~TestPoolOwner() = default;
+
+ReturnValue_t TestPoolOwner::initialize() {
+  sharedPool.addPoolEntry(lpool::uint8VarId, &u8PoolEntry);
+  sharedPool.addPoolEntry(lpool::floatVarId, &floatPoolEntry);
+  sharedPool.addPoolEntry(lpool::uint32VarId, &u32PoolEntry);
+  sharedPool.addPoolEntry(lpool::uint16Vec3Id, &u16VecPoolEntry);
+  sharedPool.addPoolEntry(lpool::int64Vec2Id, &i64VecPoolEntry);
+  ReturnValue_t result = hkHelper.initialize(&queue);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return SystemObject::initialize();
+}
+
+SharedPool *TestPoolOwner::getOptionalSharedPool() { return &sharedPool; }
+
+ReturnValue_t TestPoolOwner::serializeHkDataset(structure_id_t structureId, uint8_t *buf,
+                                                size_t maxSize) {
+  size_t dummy = 0;
+  if (structureId == testSid0) {
+    return set0.serialize(buf, dummy, maxSize, SerializeIF::Endianness::NETWORK);
+  }
+  if (structureId == testSid1) {
+    return set1.serialize(buf, dummy, maxSize, SerializeIF::Endianness::NETWORK);
+  }
+  if (structureId == testSid2) {
+    return set2.serialize(buf, dummy, maxSize, SerializeIF::Endianness::NETWORK);
+  }
+  return returnvalue::FAILED;
+}
+
+ReturnValue_t TestPoolOwner::specifyHkDatasets(std::vector<hk::SetSpecification> &setList) {
+  // For the first set, we explicitely associate a set with an ID ourselves.
+  setList.emplace_back(testSid0, set0.getSerializedSize(), 50);
+  // For the other sets, we can use getter functions of the same structure.
+  setList.emplace_back(set1.getStructureId(), set1.getSerializedSize(), 50);
+  setList.emplace_back(set2.getStructureId(), set2.getSerializedSize(), 50);
+  return returnvalue::OK;
+}
+
+ReturnValue_t TestPoolOwner::reset() {
+  ReturnValue_t status = returnvalue::OK;
+  {
+    PoolReadGuard readHelper(&set1);
+    if (readHelper.getReadResult() != returnvalue::OK) {
+      status = readHelper.getReadResult();
+    }
+    set1.localPoolVarUint8.value = 0;
+    set1.localPoolVarFloat.value = 0.0;
+    set1.localPoolUint16Vec.value[0] = 0;
+    set1.localPoolUint16Vec.value[1] = 0;
+    set1.localPoolUint16Vec.value[2] = 0;
+    // dataset.setValidity(false, true);
+  }
+
+  {
+    PoolReadGuard readHelper(&testUint32);
+    if (readHelper.getReadResult() != returnvalue::OK) {
+      status = readHelper.getReadResult();
+    }
+    testUint32.value = 0;
+  }
+
+  {
+    PoolReadGuard readHelper(&testInt64Vec);
+    if (readHelper.getReadResult() != returnvalue::OK) {
+      status = readHelper.getReadResult();
+    }
+    testInt64Vec.value[0] = 0;
+    testInt64Vec.value[1] = 0;
+  }
+  return status;
+}
+
+void TestPoolOwner::setHkDestId(MessageQueueId_t id) { hkHelper.setHkDestinationId(id); }
diff --git a/unittests/mock/TestPoolOwner.h b/unittests/mock/TestPoolOwner.h
new file mode 100644
index 00000000..9d90d316
--- /dev/null
+++ b/unittests/mock/TestPoolOwner.h
@@ -0,0 +1,65 @@
+#pragma once
+#include <fsfw/housekeeping/GeneratesPeriodicHkIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+
+#include "poolDefinitions.h"
+
+namespace lpool {
+
+class TestPoolOwner : public SystemObject, public hk::GeneratesPeriodicHkIF {
+ public:
+  explicit TestPoolOwner(MessageQueueIF& queue, MessageQueueId_t hkDestId,
+                         object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE);
+
+  ~TestPoolOwner() override;
+
+  [[nodiscard]] object_id_t getObjectId() const override { return SystemObject::getObjectId(); }
+
+  ReturnValue_t serializeHkDataset(structure_id_t structureId, uint8_t* buf,
+                                   size_t maxSize) override;
+
+  ReturnValue_t specifyHkDatasets(std::vector<hk::SetSpecification>& setList) override;
+
+  SharedPool* getOptionalSharedPool() override;
+  ReturnValue_t initialize() override;
+
+  void setHkDestId(MessageQueueId_t id);
+
+  /** Command queue for housekeeping messages. */
+  [[nodiscard]] MessageQueueId_t getCommandQueue() const override { return queue.getId(); }
+
+  [[nodiscard]] MessageQueueMock& getMockQueueHandle() const {
+    return dynamic_cast<MessageQueueMock&>(queue);
+  }
+
+  ReturnValue_t enablePeriodicHk(dp::structure_id_t structureId, dur_millis_t frequencyMs) {
+    return hkHelper.enablePeriodicPacket(structureId, frequencyMs);
+  }
+
+  ReturnValue_t reset();
+
+  hk::PeriodicHelper hkHelper;
+  SharedPool sharedPool;
+  Dataset set0;
+  StaticTestDataset set1;
+  TestDataset set2;
+
+ private:
+  PoolEntry<uint8_t> u8PoolEntry = PoolEntry<uint8_t>({0});
+  PoolEntry<float> floatPoolEntry = PoolEntry<float>({0});
+  PoolEntry<uint32_t> u32PoolEntry = PoolEntry<uint32_t>({0});
+  PoolEntry<uint16_t> u16VecPoolEntry = PoolEntry<uint16_t>({0, 0, 0});
+  PoolEntry<int64_t> i64VecPoolEntry = PoolEntry<int64_t>({0, 0});
+
+  dp::u8_t testUint8{sharedPool, lpool::uint8VarId};
+  dp::f32_t testFloat{sharedPool, lpool::floatVarId};
+  dp::u32_t testUint32{sharedPool, lpool::uint32VarId};
+  vec_t<uint16_t, 3> testUint16Vec{sharedPool, lpool::uint16Vec3Id};
+  vec_t<int64_t, 2> testInt64Vec{sharedPool, lpool::int64Vec2Id};
+
+  MessageQueueIF& queue;
+
+  bool initialized = false;
+  bool initializedAfterTaskCreation = false;
+};
+}  // namespace lpool
\ No newline at end of file
diff --git a/unittests/mocks/cfdp/CMakeLists.txt b/unittests/mock/cfdp/CMakeLists.txt
similarity index 100%
rename from unittests/mocks/cfdp/CMakeLists.txt
rename to unittests/mock/cfdp/CMakeLists.txt
diff --git a/unittests/mocks/cfdp/FaultHandlerMock.cpp b/unittests/mock/cfdp/FaultHandlerMock.cpp
similarity index 100%
rename from unittests/mocks/cfdp/FaultHandlerMock.cpp
rename to unittests/mock/cfdp/FaultHandlerMock.cpp
diff --git a/unittests/mocks/cfdp/FaultHandlerMock.h b/unittests/mock/cfdp/FaultHandlerMock.h
similarity index 100%
rename from unittests/mocks/cfdp/FaultHandlerMock.h
rename to unittests/mock/cfdp/FaultHandlerMock.h
diff --git a/unittests/mocks/cfdp/RemoteConfigTableMock.cpp b/unittests/mock/cfdp/RemoteConfigTableMock.cpp
similarity index 100%
rename from unittests/mocks/cfdp/RemoteConfigTableMock.cpp
rename to unittests/mock/cfdp/RemoteConfigTableMock.cpp
diff --git a/unittests/mocks/cfdp/RemoteConfigTableMock.h b/unittests/mock/cfdp/RemoteConfigTableMock.h
similarity index 100%
rename from unittests/mocks/cfdp/RemoteConfigTableMock.h
rename to unittests/mock/cfdp/RemoteConfigTableMock.h
diff --git a/unittests/mocks/cfdp/UserMock.cpp b/unittests/mock/cfdp/UserMock.cpp
similarity index 100%
rename from unittests/mocks/cfdp/UserMock.cpp
rename to unittests/mock/cfdp/UserMock.cpp
diff --git a/unittests/mocks/cfdp/UserMock.h b/unittests/mock/cfdp/UserMock.h
similarity index 100%
rename from unittests/mocks/cfdp/UserMock.h
rename to unittests/mock/cfdp/UserMock.h
diff --git a/unittests/mock/poolDefinitions.h b/unittests/mock/poolDefinitions.h
new file mode 100644
index 00000000..0df455e1
--- /dev/null
+++ b/unittests/mock/poolDefinitions.h
@@ -0,0 +1,73 @@
+#pragma once
+
+#include <fsfw/datapool.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/serialize/SerializableList.h>
+#include <fsfw/serialize/SerializableListElement.h>
+
+#include "fsfw/datapool/PoolEntry.h"
+#include "mock/MessageQueueMock.h"
+#include "tests/TestsConfig.h"
+
+namespace lpool {
+
+using namespace dp;
+using namespace serialize;
+
+static constexpr id_t uint8VarId = 0;
+static constexpr id_t floatVarId = 1;
+static constexpr id_t uint32VarId = 2;
+static constexpr id_t uint16Vec3Id = 3;
+static constexpr id_t int64Vec2Id = 4;
+
+static constexpr uint32_t testSetId0 = 0;
+static constexpr uint32_t testSetId1 = 1;
+static constexpr uint32_t testSetId2 = 2;
+static constexpr uint8_t dataSetMaxVariables = 10;
+
+static constexpr auto testSid0 = structure_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, testSetId0);
+static constexpr auto testSid1 = structure_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, testSetId1);
+static constexpr auto testSid2 = structure_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, testSetId2);
+
+static const g_id_t uint8VarGpid = g_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, uint8VarId);
+static const g_id_t floatVarGpid = g_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, floatVarId);
+static const g_id_t uint32Gpid = g_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, uint32VarId);
+static const g_id_t uint16Vec3Gpid = g_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, uint16Vec3Id);
+static const g_id_t uint64Vec2Id = g_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, int64Vec2Id);
+
+class Dataset : public List {
+ public:
+  LVar<uint8_t> u8Element{*this};
+  LVar<uint16_t> u16Element{*this};
+  LVec<float, 3> floatVec{*this};
+};
+
+class StaticTestDataset : public StaticSharedSet<3> {
+ public:
+  StaticTestDataset() : StaticSharedSet(lpool::testSid1) {}
+
+  StaticTestDataset(SharedPool& sharedPool, uint32_t setId) : StaticSharedSet(sharedPool, setId) {}
+
+  u8_t localPoolVarUint8{lpool::uint8VarGpid, this};
+  f32_t localPoolVarFloat{lpool::floatVarGpid, this};
+  vec_t<uint16_t, 3> localPoolUint16Vec{lpool::uint16Vec3Gpid, this};
+
+ private:
+};
+
+class TestDataset : public SharedSet {
+ public:
+  TestDataset() : SharedSet(lpool::testSid2, lpool::dataSetMaxVariables) {}
+
+  TestDataset(SharedPool& sharedPool, uint32_t setId)
+      : SharedSet(sharedPool, setId, lpool::dataSetMaxVariables) {}
+
+  u8_t localPoolVarUint8{lpool::uint8VarGpid, this};
+  f32_t localPoolVarFloat{lpool::floatVarGpid, this};
+  vec_t<uint16_t, 3> localPoolUint16Vec{lpool::uint16Vec3Gpid, this};
+
+ private:
+};
+
+}  // namespace lpool
\ No newline at end of file
diff --git a/unittests/mocks/LocalPoolOwnerBase.cpp b/unittests/mocks/LocalPoolOwnerBase.cpp
deleted file mode 100644
index e1f2f0c5..00000000
--- a/unittests/mocks/LocalPoolOwnerBase.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-#include "LocalPoolOwnerBase.h"
-
-LocalPoolOwnerBase::LocalPoolOwnerBase(MessageQueueIF &queue, object_id_t objectId)
-    : SystemObject(objectId),
-      queue(queue),
-      poolManager(this, &queue),
-      dataset(this, lpool::testSetId) {}
-
-LocalPoolOwnerBase::~LocalPoolOwnerBase() = default;
-
-ReturnValue_t LocalPoolOwnerBase::initializeHkManager() {
-  if (not initialized) {
-    initialized = true;
-    return poolManager.initialize(&queue);
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t LocalPoolOwnerBase::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                                          LocalDataPoolManager &poolManager) {
-  // Default initialization empty for now.
-  localDataPoolMap.emplace(lpool::uint8VarId, &u8PoolEntry);
-  localDataPoolMap.emplace(lpool::floatVarId, &floatPoolEntry);
-  localDataPoolMap.emplace(lpool::uint32VarId, &u32PoolEntry);
-
-  localDataPoolMap.emplace(lpool::uint16Vec3Id, &u16VecPoolEntry);
-  localDataPoolMap.emplace(lpool::int64Vec2Id, &i64VecPoolEntry);
-  return returnvalue::OK;
-}
-
-LocalPoolObjectBase *LocalPoolOwnerBase::getPoolObjectHandle(lp_id_t localPoolId) {
-  if (localPoolId == lpool::uint8VarId) {
-    return &testUint8;
-  } else if (localPoolId == lpool::uint16Vec3Id) {
-    return &testUint16Vec;
-  } else if (localPoolId == lpool::floatVarId) {
-    return &testFloat;
-  } else if (localPoolId == lpool::int64Vec2Id) {
-    return &testInt64Vec;
-  } else if (localPoolId == lpool::uint32VarId) {
-    return &testUint32;
-  } else {
-    return &testUint8;
-  }
-}
-
-ReturnValue_t LocalPoolOwnerBase::reset() {
-  resetSubscriptionList();
-  ReturnValue_t status = returnvalue::OK;
-  {
-    PoolReadGuard readHelper(&dataset);
-    if (readHelper.getReadResult() != returnvalue::OK) {
-      status = readHelper.getReadResult();
-    }
-    dataset.localPoolVarUint8.value = 0;
-    dataset.localPoolVarFloat.value = 0.0;
-    dataset.localPoolUint16Vec.value[0] = 0;
-    dataset.localPoolUint16Vec.value[1] = 0;
-    dataset.localPoolUint16Vec.value[2] = 0;
-    dataset.setValidity(false, true);
-  }
-
-  {
-    PoolReadGuard readHelper(&testUint32);
-    if (readHelper.getReadResult() != returnvalue::OK) {
-      status = readHelper.getReadResult();
-    }
-    testUint32.value = 0;
-    testUint32.setValid(false);
-  }
-
-  {
-    PoolReadGuard readHelper(&testInt64Vec);
-    if (readHelper.getReadResult() != returnvalue::OK) {
-      status = readHelper.getReadResult();
-    }
-    testInt64Vec.value[0] = 0;
-    testInt64Vec.value[1] = 0;
-    testInt64Vec.setValid(false);
-  }
-  return status;
-}
-
-bool LocalPoolOwnerBase::changedDataSetCallbackWasCalled(sid_t &sid, store_address_t &storeId) {
-  bool condition = false;
-  if (not this->changedDatasetSid.notSet()) {
-    condition = true;
-  }
-  sid = changedDatasetSid;
-  storeId = storeIdForChangedSet;
-  this->changedDatasetSid.raw = sid_t::INVALID_SID;
-  this->storeIdForChangedSet = store_address_t::invalid();
-  return condition;
-}
-
-void LocalPoolOwnerBase::handleChangedDataset(sid_t sid, store_address_t storeId,
-                                              bool *clearMessage) {
-  this->changedDatasetSid = sid;
-  this->storeIdForChangedSet = storeId;
-}
-
-bool LocalPoolOwnerBase::changedVariableCallbackWasCalled(gp_id_t &gpid, store_address_t &storeId) {
-  bool condition = false;
-  if (not this->changedPoolVariableGpid.notSet()) {
-    condition = true;
-  }
-  gpid = changedPoolVariableGpid;
-  storeId = storeIdForChangedVariable;
-  this->changedPoolVariableGpid.raw = gp_id_t::INVALID_GPID;
-  this->storeIdForChangedVariable = store_address_t::invalid();
-  return condition;
-}
-
-ReturnValue_t LocalPoolOwnerBase::initializeHkManagerAfterTaskCreation() {
-  if (not initializedAfterTaskCreation) {
-    initializedAfterTaskCreation = true;
-    return poolManager.initializeAfterTaskCreation();
-  }
-  return returnvalue::OK;
-}
-
-void LocalPoolOwnerBase::handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
-                                                   bool *clearMessage) {
-  this->changedPoolVariableGpid = globPoolId;
-  this->storeIdForChangedVariable = storeId;
-}
-
-void LocalPoolOwnerBase::setHkDestId(MessageQueueId_t id) { poolManager.setHkDestinationId(id); }
diff --git a/unittests/mocks/LocalPoolOwnerBase.h b/unittests/mocks/LocalPoolOwnerBase.h
deleted file mode 100644
index fbb03a43..00000000
--- a/unittests/mocks/LocalPoolOwnerBase.h
+++ /dev/null
@@ -1,184 +0,0 @@
-#ifndef FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
-#define FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
-
-#include <fsfw/datapool/PoolReadGuard.h>
-#include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
-#include <fsfw/datapoollocal/LocalDataSet.h>
-#include <fsfw/datapoollocal/LocalPoolVariable.h>
-#include <fsfw/datapoollocal/LocalPoolVector.h>
-#include <fsfw/datapoollocal/StaticLocalDataSet.h>
-#include <fsfw/ipc/QueueFactory.h>
-#include <fsfw/objectmanager/SystemObject.h>
-
-#include "fsfw/datapool/PoolEntry.h"
-#include "mocks/MessageQueueMock.h"
-#include "tests/TestsConfig.h"
-
-namespace lpool {
-static constexpr lp_id_t uint8VarId = 0;
-static constexpr lp_id_t floatVarId = 1;
-static constexpr lp_id_t uint32VarId = 2;
-static constexpr lp_id_t uint16Vec3Id = 3;
-static constexpr lp_id_t int64Vec2Id = 4;
-
-static constexpr uint32_t testSetId = 0;
-static constexpr uint8_t dataSetMaxVariables = 10;
-
-static const sid_t testSid = sid_t(objects::TEST_LOCAL_POOL_OWNER_BASE, testSetId);
-
-static const gp_id_t uint8VarGpid = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, uint8VarId);
-static const gp_id_t floatVarGpid = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, floatVarId);
-static const gp_id_t uint32Gpid = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, uint32VarId);
-static const gp_id_t uint16Vec3Gpid = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, uint16Vec3Id);
-static const gp_id_t uint64Vec2Id = gp_id_t(objects::TEST_LOCAL_POOL_OWNER_BASE, int64Vec2Id);
-}  // namespace lpool
-
-class LocalPoolStaticTestDataSet : public StaticLocalDataSet<3> {
- public:
-  LocalPoolStaticTestDataSet() : StaticLocalDataSet(lpool::testSid) {}
-
-  LocalPoolStaticTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId)
-      : StaticLocalDataSet(owner, setId) {}
-
-  lp_var_t<uint8_t> localPoolVarUint8 = lp_var_t<uint8_t>(lpool::uint8VarGpid, this);
-  lp_var_t<float> localPoolVarFloat = lp_var_t<float>(lpool::floatVarGpid, this);
-  lp_vec_t<uint16_t, 3> localPoolUint16Vec = lp_vec_t<uint16_t, 3>(lpool::uint16Vec3Gpid, this);
-
- private:
-};
-
-class LocalPoolTestDataSet : public LocalDataSet {
- public:
-  LocalPoolTestDataSet() : LocalDataSet(lpool::testSid, lpool::dataSetMaxVariables) {}
-
-  LocalPoolTestDataSet(HasLocalDataPoolIF* owner, uint32_t setId)
-      : LocalDataSet(owner, setId, lpool::dataSetMaxVariables) {}
-
-  lp_var_t<uint8_t> localPoolVarUint8 = lp_var_t<uint8_t>(lpool::uint8VarGpid, this);
-  lp_var_t<float> localPoolVarFloat = lp_var_t<float>(lpool::floatVarGpid, this);
-  lp_vec_t<uint16_t, 3> localPoolUint16Vec = lp_vec_t<uint16_t, 3>(lpool::uint16Vec3Gpid, this);
-
- private:
-};
-
-class LocalPoolOwnerBase : public SystemObject, public HasLocalDataPoolIF {
- public:
-  explicit LocalPoolOwnerBase(MessageQueueIF& queue,
-                              object_id_t objectId = objects::TEST_LOCAL_POOL_OWNER_BASE);
-
-  ~LocalPoolOwnerBase() override;
-
-  [[nodiscard]] object_id_t getObjectId() const override { return SystemObject::getObjectId(); }
-
-  ReturnValue_t initializeHkManager();
-
-  void setHkDestId(MessageQueueId_t id);
-
-  ReturnValue_t initializeHkManagerAfterTaskCreation();
-
-  /** Command queue for housekeeping messages. */
-  [[nodiscard]] MessageQueueId_t getCommandQueue() const override { return queue.getId(); }
-
-  // This is called by initializeAfterTaskCreation of the HK manager.
-  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                        LocalDataPoolManager& poolManager) override;
-
-  LocalDataPoolManager* getHkManagerHandle() override { return &poolManager; }
-
-  [[nodiscard]] dur_millis_t getPeriodicOperationFrequency() const override { return 200; }
-
-  /**
-   * This function is used by the pool manager to get a valid dataset
-   * from a SID
-   * @param sid Corresponding structure ID
-   * @return
-   */
-  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override { return &dataset; }
-
-  LocalPoolObjectBase* getPoolObjectHandle(lp_id_t localPoolId) override;
-
-  [[nodiscard]] MessageQueueMock& getMockQueueHandle() const {
-    return dynamic_cast<MessageQueueMock&>(queue);
-  }
-
-  ReturnValue_t subscribePeriodicHk(bool enableReporting) {
-    return poolManager.subscribeForRegularPeriodicPacket(
-        subdp::RegularHkPeriodicParams(lpool::testSid, enableReporting, 0.2));
-  }
-
-  ReturnValue_t subscribeWrapperSetUpdate(MessageQueueId_t receiverId) {
-    return poolManager.subscribeForSetUpdateMessage(lpool::testSetId, objects::NO_OBJECT,
-                                                    receiverId, false);
-  }
-
-  ReturnValue_t subscribeWrapperSetUpdateSnapshot(MessageQueueId_t receiverId) {
-    return poolManager.subscribeForSetUpdateMessage(lpool::testSetId, objects::NO_OBJECT,
-                                                    receiverId, true);
-  }
-
-  ReturnValue_t subscribeWrapperSetUpdateHk(bool diagnostics = false,
-                                            AcceptsHkPacketsIF* receiver = nullptr) {
-    if (diagnostics) {
-      auto params = subdp::DiagnosticsHkUpdateParams(lpool::testSid, true);
-      if (receiver != nullptr) {
-        params.receiver = receiver->getHkQueue();
-      }
-      return poolManager.subscribeForDiagUpdatePacket(params);
-    } else {
-      auto params = subdp::RegularHkUpdateParams(lpool::testSid, true);
-      if (receiver != nullptr) {
-        params.receiver = receiver->getHkQueue();
-      }
-      return poolManager.subscribeForRegularUpdatePacket(params);
-    }
-  }
-
-  ReturnValue_t subscribeWrapperVariableUpdate(MessageQueueId_t receiverId, lp_id_t localPoolId) {
-    return poolManager.subscribeForVariableUpdateMessage(localPoolId, MessageQueueIF::NO_QUEUE,
-                                                         receiverId, false);
-  }
-
-  ReturnValue_t subscribeWrapperVariableSnapshot(MessageQueueId_t receiverId, lp_id_t localPoolId) {
-    return poolManager.subscribeForVariableUpdateMessage(localPoolId, MessageQueueIF::NO_QUEUE,
-                                                         receiverId, true);
-  }
-
-  ReturnValue_t reset();
-
-  void resetSubscriptionList() { poolManager.clearReceiversList(); }
-
-  bool changedDataSetCallbackWasCalled(sid_t& sid, store_address_t& storeId);
-  bool changedVariableCallbackWasCalled(gp_id_t& gpid, store_address_t& storeId);
-
-  LocalDataPoolManager poolManager;
-  LocalPoolTestDataSet dataset;
-
- private:
-  void handleChangedDataset(sid_t sid, store_address_t storeId, bool* clearMessage) override;
-  sid_t changedDatasetSid;
-  store_address_t storeIdForChangedSet;
-
-  void handleChangedPoolVariable(gp_id_t globPoolId, store_address_t storeId,
-                                 bool* clearMessage) override;
-  gp_id_t changedPoolVariableGpid;
-  store_address_t storeIdForChangedVariable;
-
-  PoolEntry<uint8_t> u8PoolEntry = PoolEntry<uint8_t>({0});
-  PoolEntry<float> floatPoolEntry = PoolEntry<float>({0});
-  PoolEntry<uint32_t> u32PoolEntry = PoolEntry<uint32_t>({0});
-  PoolEntry<uint16_t> u16VecPoolEntry = PoolEntry<uint16_t>({0, 0, 0});
-  PoolEntry<int64_t> i64VecPoolEntry = PoolEntry<int64_t>({0, 0});
-
-  lp_var_t<uint8_t> testUint8 = lp_var_t<uint8_t>(this, lpool::uint8VarId);
-  lp_var_t<float> testFloat = lp_var_t<float>(this, lpool::floatVarId);
-  lp_var_t<uint32_t> testUint32 = lp_var_t<uint32_t>(this, lpool::uint32VarId);
-  lp_vec_t<uint16_t, 3> testUint16Vec = lp_vec_t<uint16_t, 3>(this, lpool::uint16Vec3Id);
-  lp_vec_t<int64_t, 2> testInt64Vec = lp_vec_t<int64_t, 2>(this, lpool::int64Vec2Id);
-
-  MessageQueueIF& queue;
-
-  bool initialized = false;
-  bool initializedAfterTaskCreation = false;
-};
-
-#endif /* FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_ */
diff --git a/unittests/power/testPowerSwitcher.cpp b/unittests/power/testPowerSwitcher.cpp
index 222dccf6..11ef6b9d 100644
--- a/unittests/power/testPowerSwitcher.cpp
+++ b/unittests/power/testPowerSwitcher.cpp
@@ -3,7 +3,7 @@
 
 #include <catch2/catch_test_macros.hpp>
 
-#include "mocks/PowerSwitcherMock.h"
+#include "mock/PowerSwitcherMock.h"
 #include "objects/systemObjectList.h"
 
 TEST_CASE("Power Switcher", "[power-switcher]") {
diff --git a/unittests/serialize/CMakeLists.txt b/unittests/serialize/CMakeLists.txt
index b42be1d5..5a786d87 100644
--- a/unittests/serialize/CMakeLists.txt
+++ b/unittests/serialize/CMakeLists.txt
@@ -1,3 +1,4 @@
 target_sources(
-  ${FSFW_TEST_TGT} PRIVATE testSerialBufferAdapter.cpp testSerializeAdapter.cpp
-                           testSerialLinkedPacket.cpp testSerializeIF.cpp)
+  ${FSFW_TEST_TGT}
+  PRIVATE testSerialBufferAdapter.cpp testSerializeAdapter.cpp
+          testSerialLinkedPacket.cpp testSerializeIF.cpp testList.cpp)
diff --git a/unittests/serialize/testList.cpp b/unittests/serialize/testList.cpp
new file mode 100644
index 00000000..19fbb4cd
--- /dev/null
+++ b/unittests/serialize/testList.cpp
@@ -0,0 +1,94 @@
+#include <catch2/catch_test_macros.hpp>
+
+#include "fsfw/serialize/SerializableList.h"
+#include "fsfw/serialize/SerializableListElement.h"
+
+using namespace serialize;
+
+class ExampleSet0 : public List {
+ public:
+  LVar<uint8_t> val0{*this};
+  LVar<uint32_t> val1{*this};
+  LVec<uint16_t, 3> val2{*this};
+};
+
+using namespace returnvalue;
+
+TEST_CASE("Serial List", "[serialize]") {
+  ExampleSet0 set0;
+  uint8_t buf[1024]{};
+  size_t serSize = 0;
+  size_t dummy = 0;
+  SECTION("serialization default") {
+    uint8_t* ptr = buf;
+    CHECK(set0.getSerializedSize() == 11);
+    const ReturnValue_t result =
+        set0.serialize(&ptr, &serSize, sizeof(buf), SerializeIF::Endianness::NETWORK);
+    CHECK(result == returnvalue::OK);
+    CHECK(ptr == buf + 11);
+    CHECK(buf[0] == 0);
+    uint32_t u32Val = 0;
+    CHECK(SerializeAdapter::deSerialize(&u32Val, buf + 1, &dummy,
+                                        SerializeIF::Endianness::NETWORK) == OK);
+    CHECK(u32Val == 0);
+    uint16_t u16Val = 0;
+    for (uint32_t i = 0; i < 3; i++) {
+      CHECK(SerializeAdapter::deSerialize(&u16Val, buf + 5, &dummy,
+                                          SerializeIF::Endianness::NETWORK) == OK);
+      CHECK(u16Val == 0);
+    }
+  }
+
+  SECTION("serialization with values") {
+    uint8_t* ptr = buf;
+    set0.val0 = 240;
+    set0.val1 = 0x1f1f1f1f;
+    set0.val2[0] = 0x1f1f;
+    set0.val2[1] = 0xf1f1;
+    set0.val2[2] = 0x4242;
+    const ReturnValue_t result =
+        set0.serialize(&ptr, &serSize, sizeof(buf), SerializeIF::Endianness::NETWORK);
+    CHECK(result == returnvalue::OK);
+    dummy = set0.getSerializedSize();
+    CHECK(ptr == buf + 11);
+    CHECK(buf[0] == 240);
+    const uint8_t* cPtr = buf + 1;
+    uint32_t u32Val = 0;
+    CHECK(SerializeAdapter::deSerialize(&u32Val, &cPtr, &dummy, SerializeIF::Endianness::NETWORK) ==
+          OK);
+    CHECK(u32Val == 0x1f1f1f1f);
+    uint16_t u16Val = 0;
+    CHECK(SerializeAdapter::deSerialize(&u16Val, &cPtr, &dummy, SerializeIF::Endianness::NETWORK) ==
+          OK);
+    CHECK(u16Val == 0x1f1f);
+    CHECK(SerializeAdapter::deSerialize(&u16Val, &cPtr, &dummy, SerializeIF::Endianness::NETWORK) ==
+          OK);
+    CHECK(u16Val == 0xf1f1);
+    CHECK(SerializeAdapter::deSerialize(&u16Val, &cPtr, &dummy, SerializeIF::Endianness::NETWORK) ==
+          OK);
+    CHECK(u16Val == 0x4242);
+  }
+
+  SECTION("deserialization with values") {
+    uint8_t* ptr = buf;
+    set0.val0 = 240;
+    set0.val1 = 0x1f1f1f1f;
+    set0.val2[0] = 0x1f1f;
+    set0.val2[1] = 0xf1f1;
+    set0.val2[2] = 0x4242;
+    const ReturnValue_t result =
+        set0.serialize(&ptr, &serSize, sizeof(buf), SerializeIF::Endianness::NETWORK);
+    CHECK(result == returnvalue::OK);
+    const uint8_t* cPtr = buf;
+    dummy = set0.getSerializedSize();
+    ExampleSet0 deserSet;
+    CHECK(deserSet.deSerialize(&cPtr, &dummy, SerializeIF::Endianness::NETWORK) == returnvalue::OK);
+
+    CHECK(deserSet.val0.get() == 240);
+    CHECK(deserSet.val1.get() == 0x1f1f1f1f);
+    CHECK(deserSet.val2[0] == 0x1f1f);
+    CHECK(deserSet.val2[1] == 0xf1f1);
+    CHECK(deserSet.val2[2] == 0x4242);
+    CHECK(dummy == 0);
+  }
+}
\ No newline at end of file
diff --git a/unittests/serialize/testSerializeIF.cpp b/unittests/serialize/testSerializeIF.cpp
index 30ad58e5..baa686bf 100644
--- a/unittests/serialize/testSerializeIF.cpp
+++ b/unittests/serialize/testSerializeIF.cpp
@@ -2,7 +2,7 @@
 #include <array>
 #include <catch2/catch_test_macros.hpp>
 
-#include "mocks/SimpleSerializable.h"
+#include "mock/SimpleSerializable.h"
 
 using namespace std;
 
diff --git a/unittests/tcdistributor/testCcsdsDistributor.cpp b/unittests/tcdistributor/testCcsdsDistributor.cpp
index c8aa81f7..8e54f440 100644
--- a/unittests/tcdistributor/testCcsdsDistributor.cpp
+++ b/unittests/tcdistributor/testCcsdsDistributor.cpp
@@ -4,14 +4,14 @@
 #include "fsfw/storagemanager/LocalPool.h"
 #include "fsfw/tcdistribution/CcsdsDistributor.h"
 #include "fsfw/tmtcpacket/ccsds/SpacePacketCreator.h"
-#include "mocks/AcceptsTcMock.h"
-#include "mocks/CcsdsCheckerMock.h"
-#include "mocks/MessageQueueMock.h"
+#include "mock/AcceptsTcMock.h"
+#include "mock/CcsdsCheckerMock.h"
+#include "mock/MessageQueueMock.h"
 
 TEST_CASE("CCSDS Distributor", "[ccsds][tmtcdistrib]") {
   LocalPool::LocalPoolConfig cfg = {{5, 32}, {2, 64}};
   LocalPool pool(objects::NO_OBJECT, cfg);
-  auto queue = MessageQueueMock(1);
+  auto queue = MessageQueueMock(1, MessageQueueIF::NO_QUEUE);
   auto checkerMock = CcsdsCheckerMock();
   uint16_t unregisteredApid = 0;
   uint16_t defaultApid = 4;
diff --git a/unittests/tmtcpacket/testPusTcCreator.cpp b/unittests/tmtcpacket/testPusTcCreator.cpp
index 58f8cbf9..fd041811 100644
--- a/unittests/tmtcpacket/testPusTcCreator.cpp
+++ b/unittests/tmtcpacket/testPusTcCreator.cpp
@@ -3,7 +3,7 @@
 
 #include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/tmtcpacket/pus/tc.h"
-#include "mocks/SimpleSerializable.h"
+#include "mock/SimpleSerializable.h"
 
 TEST_CASE("PUS TC Creator", "[pus-tc-creator]") {
   auto packetId = PacketId(ccsds::PacketType::TC, true, 0x02);
diff --git a/unittests/tmtcpacket/testPusTmCreator.cpp b/unittests/tmtcpacket/testPusTmCreator.cpp
index fc86dcbe..7bc9955f 100644
--- a/unittests/tmtcpacket/testPusTmCreator.cpp
+++ b/unittests/tmtcpacket/testPusTmCreator.cpp
@@ -3,8 +3,8 @@
 #include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/globalfunctions/arrayprinter.h"
 #include "fsfw/tmtcpacket/pus/tm.h"
-#include "mocks/CdsShortTimestamperMock.h"
-#include "mocks/SimpleSerializable.h"
+#include "mock/CdsShortTimestamperMock.h"
+#include "mock/SimpleSerializable.h"
 
 TEST_CASE("PUS TM Creator", "[pus-tm-creator]") {
   auto packetId = PacketId(ccsds::PacketType::TC, true, 0xef);
diff --git a/unittests/tmtcpacket/testPusTmReader.cpp b/unittests/tmtcpacket/testPusTmReader.cpp
index 1180fd23..3e96f935 100644
--- a/unittests/tmtcpacket/testPusTmReader.cpp
+++ b/unittests/tmtcpacket/testPusTmReader.cpp
@@ -2,7 +2,7 @@
 
 #include "fsfw/tmtcpacket/pus/tm/PusTmCreator.h"
 #include "fsfw/tmtcpacket/pus/tm/PusTmReader.h"
-#include "mocks/CdsShortTimestamperMock.h"
+#include "mock/CdsShortTimestamperMock.h"
 
 TEST_CASE("PUS TM Reader", "[pus-tm-reader]") {
   auto packetId = PacketId(ccsds::PacketType::TC, true, 0xef);
diff --git a/unittests/tmtcpacket/testZcTmWriter.cpp b/unittests/tmtcpacket/testZcTmWriter.cpp
index 12e88ea1..b34c8ae1 100644
--- a/unittests/tmtcpacket/testZcTmWriter.cpp
+++ b/unittests/tmtcpacket/testZcTmWriter.cpp
@@ -3,7 +3,7 @@
 #include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/tmtcpacket/pus/tm.h"
 #include "fsfw/tmtcpacket/pus/tm/PusTmZcWriter.h"
-#include "mocks/CdsShortTimestamperMock.h"
+#include "mock/CdsShortTimestamperMock.h"
 
 TEST_CASE("TM ZC Helper", "[tm-zc-helper]") {
   auto packetId = PacketId(ccsds::PacketType::TC, true, 0xef);
diff --git a/unittests/tmtcservices/testPsb.cpp b/unittests/tmtcservices/testPsb.cpp
index 93d8aec5..3a60e421 100644
--- a/unittests/tmtcservices/testPsb.cpp
+++ b/unittests/tmtcservices/testPsb.cpp
@@ -3,18 +3,18 @@
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/storagemanager/LocalPool.h"
 #include "fsfw/storagemanager/PoolManager.h"
-#include "mocks/AcceptsTmMock.h"
-#include "mocks/CdsShortTimestamperMock.h"
-#include "mocks/InternalErrorReporterMock.h"
-#include "mocks/MessageQueueMock.h"
-#include "mocks/PusDistributorMock.h"
-#include "mocks/PusServiceBaseMock.h"
-#include "mocks/PusVerificationReporterMock.h"
+#include "mock/AcceptsTmMock.h"
+#include "mock/CdsShortTimestamperMock.h"
+#include "mock/InternalErrorReporterMock.h"
+#include "mock/MessageQueueMock.h"
+#include "mock/PusDistributorMock.h"
+#include "mock/PusServiceBaseMock.h"
+#include "mock/PusVerificationReporterMock.h"
 
 TEST_CASE("Pus Service Base", "[pus-service-base]") {
   uint16_t apid = 2;
   auto verificationReporter = PusVerificationReporterMock();
-  auto msgQueue = MessageQueueMock(1);
+  auto msgQueue = MessageQueueMock(1, MessageQueueIF::NO_QUEUE);
   auto tmReceiver = AcceptsTmMock(2);
   auto psbParams = PsbParams(0, apid, 17);
 
@@ -117,7 +117,7 @@ TEST_CASE("Pus Service Base", "[pus-service-base]") {
   }
 
   SECTION("Set Request Queue") {
-    auto msgQueueMock = MessageQueueMock(2);
+    auto msgQueueMock = MessageQueueMock(2, MessageQueueIF::NO_QUEUE);
     psb.setRequestQueue(msgQueueMock);
     auto& p = psb.getParams();
     REQUIRE(p.reqQueue == &msgQueueMock);
diff --git a/unittests/tmtcservices/testSendHelper.cpp b/unittests/tmtcservices/testSendHelper.cpp
index 07315e44..56add958 100644
--- a/unittests/tmtcservices/testSendHelper.cpp
+++ b/unittests/tmtcservices/testSendHelper.cpp
@@ -3,15 +3,14 @@
 #include "fsfw/storagemanager/LocalPool.h"
 #include "fsfw/tmtcservices/TmSendHelper.h"
 #include "fsfw/tmtcservices/TmStoreHelper.h"
-#include "mocks/CdsShortTimestamperMock.h"
-#include "mocks/InternalErrorReporterMock.h"
-#include "mocks/MessageQueueMock.h"
+#include "mock/CdsShortTimestamperMock.h"
+#include "mock/InternalErrorReporterMock.h"
+#include "mock/MessageQueueMock.h"
 
 TEST_CASE("TM Send Helper", "[tm-send-helper]") {
   MessageQueueId_t destId = 2;
   auto errReporter = InternalErrorReporterMock();
-  auto msgQueue = MessageQueueMock(1);
-  msgQueue.setDefaultDestination(destId);
+  auto msgQueue = MessageQueueMock(1, destId);
   TmSendHelper sendHelper(msgQueue, errReporter, destId);
   auto timeStamper = CdsShortTimestamperMock();
   LocalPool::LocalPoolConfig cfg = {{5, 32}, {2, 64}};
diff --git a/unittests/tmtcservices/testStoreAndSendHelper.cpp b/unittests/tmtcservices/testStoreAndSendHelper.cpp
index 6fe9f8e2..f68d687a 100644
--- a/unittests/tmtcservices/testStoreAndSendHelper.cpp
+++ b/unittests/tmtcservices/testStoreAndSendHelper.cpp
@@ -4,10 +4,10 @@
 #include "fsfw/tmtcservices/TmSendHelper.h"
 #include "fsfw/tmtcservices/TmStoreAndSendHelper.h"
 #include "fsfw/tmtcservices/TmStoreHelper.h"
-#include "mocks/CdsShortTimestamperMock.h"
-#include "mocks/InternalErrorReporterMock.h"
-#include "mocks/MessageQueueMock.h"
-#include "mocks/SimpleSerializable.h"
+#include "mock/CdsShortTimestamperMock.h"
+#include "mock/InternalErrorReporterMock.h"
+#include "mock/MessageQueueMock.h"
+#include "mock/SimpleSerializable.h"
 
 TEST_CASE("TM Store And Send Helper", "[tm-store-send-helper]") {
   auto timeStamper = CdsShortTimestamperMock();
@@ -17,8 +17,7 @@ TEST_CASE("TM Store And Send Helper", "[tm-store-send-helper]") {
 
   MessageQueueId_t destId = 1;
   auto errReporter = InternalErrorReporterMock();
-  auto msgQueue = MessageQueueMock(2);
-  msgQueue.setDefaultDestination(destId);
+  auto msgQueue = MessageQueueMock(2, destId);
   TmSendHelper sendHelper(msgQueue, errReporter, destId);
   TmStoreAndSendWrapper tmHelper(17, storeHelper, sendHelper);
 
diff --git a/unittests/tmtcservices/testStoreHelper.cpp b/unittests/tmtcservices/testStoreHelper.cpp
index dd73305d..bee92024 100644
--- a/unittests/tmtcservices/testStoreHelper.cpp
+++ b/unittests/tmtcservices/testStoreHelper.cpp
@@ -3,8 +3,8 @@
 #include "fsfw/storagemanager/LocalPool.h"
 #include "fsfw/tmtcservices/TmStoreHelper.h"
 #include "fsfw/tmtcservices/tmHelpers.h"
-#include "mocks/CdsShortTimestamperMock.h"
-#include "mocks/SimpleSerializable.h"
+#include "mock/CdsShortTimestamperMock.h"
+#include "mock/SimpleSerializable.h"
 
 TEST_CASE("TM Store Helper", "[tm-store-helper]") {
   auto timeStamper = CdsShortTimestamperMock();