diff --git a/bsp_q7s/core/ObjectFactory.cpp b/bsp_q7s/core/ObjectFactory.cpp
index 3092e69d..bdccd6fd 100644
--- a/bsp_q7s/core/ObjectFactory.cpp
+++ b/bsp_q7s/core/ObjectFactory.cpp
@@ -68,6 +68,9 @@
 #include "mission/tmtc/tmFilters.h"
 #include "mission/utility/GlobalConfigHandler.h"
 #include "tmtc/pusIds.h"
+
+using gpio::Direction;
+using gpio::Levels;
 #if OBSW_TEST_LIBGPIOD == 1
 #include "linux/boardtest/LibgpiodTest.h"
 #endif
@@ -254,106 +257,110 @@ ReturnValue_t ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF,
   return returnvalue::OK;
 }
 
-void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF,
-                                             SerialComIF* uartComIF, PowerSwitchIF& pwrSwitcher) {
-  using namespace gpio;
-  GpioCookie* gpioCookieAcsBoard = new GpioCookie();
-
+void ObjectFactory::createAcsBoardGpios(GpioCookie& cookie) {
   std::stringstream consumer;
   GpiodRegularByLineName* gpio = nullptr;
   consumer << "0x" << std::hex << objects::GYRO_0_ADIS_HANDLER;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ADIS_CS, consumer.str(), Direction::OUT,
                                     Levels::HIGH);
-  gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ADIS_CS, gpio);
+  cookie.addGpio(gpioIds::GYRO_0_ADIS_CS, gpio);
 
   consumer.str("");
   consumer << "0x" << std::hex << objects::GYRO_1_L3G_HANDLER;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_1_L3G_CS, consumer.str(), Direction::OUT,
                                     Levels::HIGH);
-  gpioCookieAcsBoard->addGpio(gpioIds::GYRO_1_L3G_CS, gpio);
+  cookie.addGpio(gpioIds::GYRO_1_L3G_CS, gpio);
 
   consumer.str("");
   consumer << "0x" << std::hex << objects::GYRO_2_ADIS_HANDLER;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ADIS_CS, consumer.str(), Direction::OUT,
                                     Levels::HIGH);
-  gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_ADIS_CS, gpio);
+  cookie.addGpio(gpioIds::GYRO_2_ADIS_CS, gpio);
 
   consumer.str("");
   consumer << "0x" << std::hex << objects::GYRO_3_L3G_HANDLER;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_3_L3G_CS, consumer.str(), Direction::OUT,
                                     Levels::HIGH);
-  gpioCookieAcsBoard->addGpio(gpioIds::GYRO_3_L3G_CS, gpio);
+  cookie.addGpio(gpioIds::GYRO_3_L3G_CS, gpio);
 
   consumer.str("");
   consumer << "0x" << std::hex << objects::MGM_0_LIS3_HANDLER;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_0_CS, consumer.str(), Direction::OUT,
                                     Levels::HIGH);
-  gpioCookieAcsBoard->addGpio(gpioIds::MGM_0_LIS3_CS, gpio);
+  cookie.addGpio(gpioIds::MGM_0_LIS3_CS, gpio);
 
   consumer.str("");
   consumer << "0x" << std::hex << objects::MGM_1_RM3100_HANDLER;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_1_CS, consumer.str(), Direction::OUT,
                                     Levels::HIGH);
-  gpioCookieAcsBoard->addGpio(gpioIds::MGM_1_RM3100_CS, gpio);
+  cookie.addGpio(gpioIds::MGM_1_RM3100_CS, gpio);
 
   consumer.str("");
   consumer << "0x" << std::hex << objects::MGM_2_LIS3_HANDLER;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_2_CS, consumer.str(), Direction::OUT,
                                     Levels::HIGH);
-  gpioCookieAcsBoard->addGpio(gpioIds::MGM_2_LIS3_CS, gpio);
+  cookie.addGpio(gpioIds::MGM_2_LIS3_CS, gpio);
 
   consumer.str("");
   consumer << "0x" << std::hex << objects::MGM_3_RM3100_HANDLER;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::MGM_3_CS, consumer.str(), Direction::OUT,
                                     Levels::HIGH);
-  gpioCookieAcsBoard->addGpio(gpioIds::MGM_3_RM3100_CS, gpio);
+  cookie.addGpio(gpioIds::MGM_3_RM3100_CS, gpio);
 
   consumer.str("");
   consumer << "0x" << std::hex << objects::GPS_CONTROLLER;
   // GNSS reset pins are active low
   gpio = new GpiodRegularByLineName(q7s::gpioNames::RESET_GNSS_0, consumer.str(), Direction::OUT,
                                     Levels::HIGH);
-  gpioCookieAcsBoard->addGpio(gpioIds::GNSS_0_NRESET, gpio);
+  cookie.addGpio(gpioIds::GNSS_0_NRESET, gpio);
 
   consumer.str("");
   consumer << "0x" << std::hex << objects::GPS_CONTROLLER;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::RESET_GNSS_1, consumer.str(), Direction::OUT,
                                     Levels::HIGH);
-  gpioCookieAcsBoard->addGpio(gpioIds::GNSS_1_NRESET, gpio);
+  cookie.addGpio(gpioIds::GNSS_1_NRESET, gpio);
 
   consumer.str("");
   consumer << "0x" << std::hex << objects::GYRO_0_ADIS_HANDLER;
   // Enable pins must be pulled low for regular operations
   gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_0_ENABLE, consumer.str(), Direction::OUT,
                                     Levels::LOW);
-  gpioCookieAcsBoard->addGpio(gpioIds::GYRO_0_ENABLE, gpio);
+  cookie.addGpio(gpioIds::GYRO_0_ENABLE, gpio);
 
   consumer.str("");
   consumer << "0x" << std::hex << objects::GYRO_2_ADIS_HANDLER;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::GYRO_2_ENABLE, consumer.str(), Direction::OUT,
                                     Levels::LOW);
-  gpioCookieAcsBoard->addGpio(gpioIds::GYRO_2_ENABLE, gpio);
+  cookie.addGpio(gpioIds::GYRO_2_ENABLE, gpio);
 
   // Enable pins for GNSS
   consumer.str("");
   consumer << "0x" << std::hex << objects::GPS_CONTROLLER;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_0_ENABLE, consumer.str(), Direction::OUT,
                                     Levels::LOW);
-  gpioCookieAcsBoard->addGpio(gpioIds::GNSS_0_ENABLE, gpio);
+  cookie.addGpio(gpioIds::GNSS_0_ENABLE, gpio);
 
   consumer.str("");
   consumer << "0x" << std::hex << objects::GPS_CONTROLLER;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_1_ENABLE, consumer.str(), Direction::OUT,
                                     Levels::LOW);
-  gpioCookieAcsBoard->addGpio(gpioIds::GNSS_1_ENABLE, gpio);
+  cookie.addGpio(gpioIds::GNSS_1_ENABLE, gpio);
 
   // Select pin. 0 for GPS side A, 1 for GPS side B
   consumer.str("");
   consumer << "0x" << std::hex << objects::GPS_CONTROLLER;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::GNSS_SELECT, consumer.str(), Direction::OUT,
                                     Levels::LOW);
-  gpioCookieAcsBoard->addGpio(gpioIds::GNSS_SELECT, gpio);
+  cookie.addGpio(gpioIds::GNSS_SELECT, gpio);
+}
+
+void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF,
+                                             SerialComIF* uartComIF, PowerSwitchIF& pwrSwitcher) {
+  using namespace gpio;
+  GpioCookie* gpioCookieAcsBoard = new GpioCookie();
+  createAcsBoardGpios(*gpioCookieAcsBoard);
   gpioChecker(gpioComIF->addGpios(gpioCookieAcsBoard), "ACS Board");
+
   AcsBoardFdir* fdir = nullptr;
   static_cast<void>(fdir);
 
diff --git a/bsp_q7s/core/ObjectFactory.h b/bsp_q7s/core/ObjectFactory.h
index 7b713005..c0da31d4 100644
--- a/bsp_q7s/core/ObjectFactory.h
+++ b/bsp_q7s/core/ObjectFactory.h
@@ -55,6 +55,7 @@ void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
                             PowerSwitchIF* pwrSwitcher, Stack5VHandler& stackHandler);
 void createTmpComponents();
 ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF, Stack5VHandler& handler);
+void createAcsBoardGpios(GpioCookie& cookie);
 void createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF, SerialComIF* uartComIF,
                               PowerSwitchIF& pwrSwitcher);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable,
diff --git a/bsp_q7s/core/scheduling.cpp b/bsp_q7s/core/scheduling.cpp
index 99bb90d2..90cd2173 100644
--- a/bsp_q7s/core/scheduling.cpp
+++ b/bsp_q7s/core/scheduling.cpp
@@ -501,7 +501,6 @@ void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction
   }
 #endif
 
-#if OBSW_ADD_GOMSPACE_PCDU == 1
   FixedTimeslotTaskIF* gomSpacePstTask = factory.createFixedTimeslotTask(
       "GS_PST_TASK", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
   result = pst::pstGompaceCan(gomSpacePstTask);
@@ -511,7 +510,6 @@ void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction
     }
   }
   taskVec.push_back(gomSpacePstTask);
-#endif
 }
 
 void scheduling::createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
diff --git a/bsp_q7s/em/emObjectFactory.cpp b/bsp_q7s/em/emObjectFactory.cpp
index 0958f3b2..501a5471 100644
--- a/bsp_q7s/em/emObjectFactory.cpp
+++ b/bsp_q7s/em/emObjectFactory.cpp
@@ -1,6 +1,7 @@
 #include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
 #include <fsfw/health/HealthTableIF.h>
 #include <fsfw/power/DummyPowerSwitcher.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
 #include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
 #include <mission/system/tree/system.h>
 #include <mission/utility/DummySdCardManager.h>
@@ -81,6 +82,11 @@ void ObjectFactory::produce(void* args) {
 
 #if OBSW_ADD_ACS_BOARD == 1
   createAcsBoardComponents(gpioComIF, uartComIF, *pwrSwitcher);
+#else
+  // Still add all GPIOs for EM.
+  GpioCookie* acsBoardGpios = new GpioCookie();
+  createAcsBoardGpios(*acsBoardGpios);
+  gpioChecker(gpioComIF->addGpios(acsBoardGpios), "ACS Board");
 #endif
 
 #if OBSW_ADD_MGT == 1
diff --git a/bsp_q7s/fmObjectFactory.cpp b/bsp_q7s/fmObjectFactory.cpp
index 5daab861..53f61528 100644
--- a/bsp_q7s/fmObjectFactory.cpp
+++ b/bsp_q7s/fmObjectFactory.cpp
@@ -104,3 +104,7 @@ void ObjectFactory::produce(void* args) {
   createAcsController(true);
   satsystem::init();
 }
+
+void ObjectFactory::createAcsBoardGpios(GpioCookie& cookie) {}
+
+void ObjectFactory::createAcsBoardGpios(GpioCookie& cookie) {}
diff --git a/dummies/AcuDummy.cpp b/dummies/AcuDummy.cpp
index d6ba21d1..aa33a068 100644
--- a/dummies/AcuDummy.cpp
+++ b/dummies/AcuDummy.cpp
@@ -7,9 +7,9 @@ AcuDummy::AcuDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
 
 AcuDummy::~AcuDummy() {}
 
-void AcuDummy::doStartUp() {}
+void AcuDummy::doStartUp() { setMode(MODE_NORMAL); }
 
-void AcuDummy::doShutDown() {}
+void AcuDummy::doShutDown() { setMode(MODE_OFF); }
 
 ReturnValue_t AcuDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
 
@@ -37,6 +37,7 @@ uint32_t AcuDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return
 
 ReturnValue_t AcuDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                 LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(ACU::pool::ACU_TEMPERATURES, new PoolEntry<float>(3));
+  localDataPoolMap.emplace(ACU::pool::ACU_TEMPERATURES,
+                           new PoolEntry<float>({10.0, 10.0, 10.0}, true));
   return returnvalue::OK;
 }
diff --git a/dummies/BpxDummy.cpp b/dummies/BpxDummy.cpp
index 525c5c46..0770e9fc 100644
--- a/dummies/BpxDummy.cpp
+++ b/dummies/BpxDummy.cpp
@@ -7,9 +7,9 @@ BpxDummy::BpxDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
 
 BpxDummy::~BpxDummy() {}
 
-void BpxDummy::doStartUp() {}
+void BpxDummy::doStartUp() { setMode(MODE_NORMAL); }
 
-void BpxDummy::doShutDown() {}
+void BpxDummy::doShutDown() { setMode(MODE_OFF); }
 
 ReturnValue_t BpxDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
 
diff --git a/dummies/BpxDummy.h b/dummies/BpxDummy.h
index 1332f36b..3c75cab7 100644
--- a/dummies/BpxDummy.h
+++ b/dummies/BpxDummy.h
@@ -34,10 +34,10 @@ class BpxDummy : public DeviceHandlerBase {
   PoolEntry<uint16_t> dischargeCurrent = PoolEntry<uint16_t>({0});
   PoolEntry<uint16_t> heaterCurrent = PoolEntry<uint16_t>({0});
   PoolEntry<uint16_t> battVolt = PoolEntry<uint16_t>({0});
-  PoolEntry<int16_t> battTemp1 = PoolEntry<int16_t>({0});
-  PoolEntry<int16_t> battTemp2 = PoolEntry<int16_t>({0});
-  PoolEntry<int16_t> battTemp3 = PoolEntry<int16_t>({0});
-  PoolEntry<int16_t> battTemp4 = PoolEntry<int16_t>({0});
+  PoolEntry<int16_t> battTemp1 = PoolEntry<int16_t>({10}, true);
+  PoolEntry<int16_t> battTemp2 = PoolEntry<int16_t>({10}, true);
+  PoolEntry<int16_t> battTemp3 = PoolEntry<int16_t>({10}, true);
+  PoolEntry<int16_t> battTemp4 = PoolEntry<int16_t>({10}, true);
   PoolEntry<uint32_t> rebootCounter = PoolEntry<uint32_t>({0});
   PoolEntry<uint8_t> bootCause = PoolEntry<uint8_t>({0});
   PoolEntry<uint8_t> battheatMode = PoolEntry<uint8_t>({0});
diff --git a/dummies/P60DockDummy.cpp b/dummies/P60DockDummy.cpp
index 8a3611ca..f4e4f9bb 100644
--- a/dummies/P60DockDummy.cpp
+++ b/dummies/P60DockDummy.cpp
@@ -7,9 +7,9 @@ P60DockDummy::P60DockDummy(object_id_t objectId, object_id_t comif, CookieIF *co
 
 P60DockDummy::~P60DockDummy() {}
 
-void P60DockDummy::doStartUp() {}
+void P60DockDummy::doStartUp() { setMode(MODE_NORMAL); }
 
-void P60DockDummy::doShutDown() {}
+void P60DockDummy::doShutDown() { setMode(MODE_OFF); }
 
 ReturnValue_t P60DockDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
@@ -40,7 +40,9 @@ uint32_t P60DockDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { re
 
 ReturnValue_t P60DockDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                     LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(P60Dock::pool::P60DOCK_TEMPERATURE_1, new PoolEntry<float>({0}));
-  localDataPoolMap.emplace(P60Dock::pool::P60DOCK_TEMPERATURE_2, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(P60Dock::pool::P60DOCK_TEMPERATURE_1,
+                           new PoolEntry<float>({10.0}, true));
+  localDataPoolMap.emplace(P60Dock::pool::P60DOCK_TEMPERATURE_2,
+                           new PoolEntry<float>({10.0}, true));
   return returnvalue::OK;
 }
diff --git a/dummies/PduDummy.cpp b/dummies/PduDummy.cpp
index 42147222..4b1efff8 100644
--- a/dummies/PduDummy.cpp
+++ b/dummies/PduDummy.cpp
@@ -8,9 +8,9 @@ PduDummy::PduDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
 
 PduDummy::~PduDummy() {}
 
-void PduDummy::doStartUp() {}
+void PduDummy::doStartUp() { setMode(MODE_NORMAL); }
 
-void PduDummy::doShutDown() {}
+void PduDummy::doShutDown() { setMode(MODE_OFF); }
 
 ReturnValue_t PduDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
 
@@ -38,7 +38,7 @@ uint32_t PduDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return
 
 ReturnValue_t PduDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                 LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(PDU::pool::PDU_TEMPERATURE, new PoolEntry<float>({0}));
+  localDataPoolMap.emplace(PDU::pool::PDU_TEMPERATURE, new PoolEntry<float>({10.0}, true));
   localDataPoolMap.emplace(PDU::pool::PDU_VOLTAGES, &pduVoltages);
   localDataPoolMap.emplace(PDU::pool::PDU_CURRENTS, &pduCurrents);
   return returnvalue::OK;
diff --git a/dummies/PlPcduDummy.cpp b/dummies/PlPcduDummy.cpp
index df4acd1b..1366f63e 100644
--- a/dummies/PlPcduDummy.cpp
+++ b/dummies/PlPcduDummy.cpp
@@ -7,9 +7,9 @@ PlPcduDummy::PlPcduDummy(object_id_t objectId, object_id_t comif, CookieIF *comC
 
 PlPcduDummy::~PlPcduDummy() {}
 
-void PlPcduDummy::doStartUp() {}
+void PlPcduDummy::doStartUp() { setMode(MODE_NORMAL); }
 
-void PlPcduDummy::doShutDown() {}
+void PlPcduDummy::doShutDown() { setMode(MODE_OFF); }
 
 ReturnValue_t PlPcduDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
   return NOTHING_TO_SEND;
@@ -40,6 +40,6 @@ uint32_t PlPcduDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { ret
 
 ReturnValue_t PlPcduDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                    LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(plpcdu::PlPcduPoolIds::TEMP, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(plpcdu::PlPcduPoolIds::TEMP, new PoolEntry<float>({0.0}, true));
   return returnvalue::OK;
 }
diff --git a/mission/core/pollingSeqTables.cpp b/mission/core/pollingSeqTables.cpp
index 79bf8868..f8a34c36 100644
--- a/mission/core/pollingSeqTables.cpp
+++ b/mission/core/pollingSeqTables.cpp
@@ -40,36 +40,38 @@ ReturnValue_t pst::pstI2c(FixedTimeslotTaskIF *thisSequence) {
   // Length of a communication cycle
   uint32_t length = thisSequence->getPeriodMs();
   static_cast<void>(length);
-#if OBSW_ADD_BPX_BATTERY_HANDLER == 1
   thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.2,
                         DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
   thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.2, DeviceHandlerIF::GET_WRITE);
   thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.3, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.3, DeviceHandlerIF::GET_READ);
-#endif
+
   // These are actually part of another bus, but this works, so keep it like this for now
   thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4,
                         DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4, DeviceHandlerIF::SEND_WRITE);
   thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.4, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4,
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.45, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.45, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.5,
                         DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.5, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.5, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.55, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.55, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.6,
                         DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.6,
                         DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.6,
                         DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.65,
                         DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.65,
+                        DeviceHandlerIF::GET_READ);
   // damaged
   /*
   thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
@@ -82,15 +84,16 @@ ReturnValue_t pst::pstI2c(FixedTimeslotTaskIF *thisSequence) {
                         DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4, DeviceHandlerIF::GET_READ);
   */
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4,
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
                         DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4,
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
                         DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4,
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
                         DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4,
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.85,
                         DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.4, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.85,
+                        DeviceHandlerIF::GET_READ);
   static_cast<void>(length);
   return thisSequence->checkSequence();
 }
@@ -549,7 +552,6 @@ ReturnValue_t pst::pstTcsAndAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg
   thisSequence->addSlot(objects::SPI_RTD_COM_IF, length * config::spiSched::SCHED_BLOCK_RTD_PERIOD,
                         0);
 
-#if OBSW_ADD_PL_PCDU == 1
   thisSequence->addSlot(objects::PLPCDU_HANDLER, length * config::spiSched::SCHED_BLOCK_8_PERIOD,
                         DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::PLPCDU_HANDLER, length * config::spiSched::SCHED_BLOCK_8_PERIOD,
@@ -560,7 +562,6 @@ ReturnValue_t pst::pstTcsAndAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg
                         DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::PLPCDU_HANDLER, length * config::spiSched::SCHED_BLOCK_8_PERIOD,
                         DeviceHandlerIF::GET_READ);
-#endif
 
 #if OBSW_ADD_RAD_SENSORS == 1
   /* Radiation sensor */
diff --git a/tmtc b/tmtc
index a40c881b..f21ee37a 160000
--- a/tmtc
+++ b/tmtc
@@ -1 +1 @@
-Subproject commit a40c881b9fc292fe598204280db38720a784b71f
+Subproject commit f21ee37a01379907ca72932264e5236a6c30f8a1