diff --git a/bsp_q7s/core/InitMission.cpp b/bsp_q7s/core/InitMission.cpp
index 024f663d..b39da7d2 100644
--- a/bsp_q7s/core/InitMission.cpp
+++ b/bsp_q7s/core/InitMission.cpp
@@ -15,6 +15,7 @@
 #include "fsfw/tasks/FixedTimeslotTaskIF.h"
 #include "fsfw/tasks/PeriodicTaskIF.h"
 #include "fsfw/tasks/TaskFactory.h"
+#include "mission/devices/devicedefinitions/Max31865Definitions.h"
 #include "mission/utility/InitMission.h"
 #include "pollingsequence/pollingSequenceFactory.h"
 
@@ -117,7 +118,7 @@ void initmission::initTasks() {
 
 #if OBSW_ADD_ACS_HANDLERS == 1
   PeriodicTaskIF* acsTask = factory->createPeriodicTask(
-      "ACS_CTRL", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
+      "ACS_TASK", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
   result = acsTask->addComponent(objects::GPS_CONTROLLER);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("GPS_CTRL", objects::GPS_CONTROLLER);
@@ -138,26 +139,42 @@ void initmission::initTasks() {
     initmission::printAddObjectError("RW_ASS", objects::RW_ASS);
   }
 #endif
-
 #if OBSW_ADD_SUS_BOARD_ASS == 1
   result = sysTask->addComponent(objects::SUS_BOARD_ASS);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("SUS_BOARD_ASS", objects::SUS_BOARD_ASS);
   }
 #endif
+
+  PeriodicTaskIF* tcsTask = factory->createPeriodicTask(
+      "TCS_TASK", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
+  std::array<object_id_t, EiveMax31855::NUM_RTDS> rtdIds = {
+      objects::RTD_0_IC3_PLOC_HEATSPREADER,
+      objects::RTD_1_IC4_PLOC_MISSIONBOARD,
+      objects::RTD_2_IC5_4K_CAMERA,
+      objects::RTD_3_IC6_DAC_HEATSPREADER,
+      objects::RTD_4_IC7_STARTRACKER,
+      objects::RTD_5_IC8_RW1_MX_MY,
+      objects::RTD_6_IC9_DRO,
+      objects::RTD_7_IC10_SCEX,
+      objects::RTD_8_IC11_X8,
+      objects::RTD_9_IC12_HPA,
+      objects::RTD_10_IC13_PL_TX,
+      objects::RTD_11_IC14_MPA,
+      objects::RTD_12_IC15_ACU,
+      objects::RTD_13_IC16_PLPCDU_HEATSPREADER,
+      objects::RTD_14_IC17_TCS_BOARD,
+      objects::RTD_15_IC18_IMTQ,
+  };
 #if OBSW_ADD_RTD_DEVICES == 1
-  result = sysTask->addComponent(objects::TCS_BOARD_ASS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    initmission::printAddObjectError("TCS_BOARD_ASS", objects::TCS_BOARD_ASS);
+  for (const auto& rtd : rtdIds) {
+    tcsTask->addComponent(rtd, DeviceHandlerIF::PERFORM_OPERATION);
+    tcsTask->addComponent(rtd, DeviceHandlerIF::SEND_WRITE);
+    tcsTask->addComponent(rtd, DeviceHandlerIF::GET_WRITE);
+    tcsTask->addComponent(rtd, DeviceHandlerIF::SEND_READ);
+    tcsTask->addComponent(rtd, DeviceHandlerIF::GET_READ);
   }
-  auto* rtdReader = ObjectManager::instance()->get<DeviceCommunicationIF>(objects::SPI_RTD_COM_IF);
-  if (rtdReader != nullptr) {
-    result = sysTask->addComponent(objects::SPI_RTD_COM_IF);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      initmission::printAddObjectError("SPI_RTD_COM_IF", objects::SPI_RTD_COM_IF);
-    }
-  }
-#endif /* OBSW_ADD_RTD_DEVICES == 1 */
+#endif /* OBSW_ADD_RTD_DEVICES */
 
   // FS task, task interval does not matter because it runs in permanent loop, priority low
   // because it is a non-essential background task
@@ -254,12 +271,9 @@ void initmission::initTasks() {
   strHelperTask->startTask();
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 
-#if OBSW_ADD_ACS_HANDLERS == 1
   acsTask->startTask();
-#endif
-#if OBSW_ADD_RTD_DEVICES == 1
   sysTask->startTask();
-#endif
+  tcsTask->startTask();
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
   supvHelperTask->startTask();
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
diff --git a/fsfw b/fsfw
index 4841d5d9..dba08fed 160000
--- a/fsfw
+++ b/fsfw
@@ -1 +1 @@
-Subproject commit 4841d5d92d721383e92b521b584c7d0e62c9873d
+Subproject commit dba08fed7a00187ba204f46bc40424f7b87f3aea
diff --git a/linux/ObjectFactory.cpp b/linux/ObjectFactory.cpp
index 7ed9c66f..fec9cc81 100644
--- a/linux/ObjectFactory.cpp
+++ b/linux/ObjectFactory.cpp
@@ -313,7 +313,7 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
     rtds[idx] = typedHandler;
     typedHandler->setDeviceInfo(idx, rtdInfos[idx].second);
 #if OBSW_DEBUG_RTD == 1
-    // typedHandler->setDebugMode(true);
+    typedHandler->setDebugMode(true, 5);
 #endif
 #if OBSW_TEST_RTD == 1
     typedHandler->setInstantNormal(true);
diff --git a/linux/devices/Max31865RtdLowlevelHandler.cpp b/linux/devices/Max31865RtdLowlevelHandler.cpp
index 9eef346e..500870c4 100644
--- a/linux/devices/Max31865RtdLowlevelHandler.cpp
+++ b/linux/devices/Max31865RtdLowlevelHandler.cpp
@@ -49,16 +49,15 @@ bool Max31865RtdReader::periodicInitHandling() {
     return false;
   }
 
-  bool someRtdOn = false;
   for (auto& rtd : rtds) {
     if (rtd == nullptr) {
       continue;
     }
     if ((rtd->on or rtd->active) and not rtd->configured) {
       if (rtd->cd.hasTimedOut()) {
-        uint8_t cfg =
-            (Bias::OFF << CfgBitPos::BIAS_SEL) | (Wires::FOUR_WIRE << CfgBitPos::WIRE_SEL) |
-            (ConvMode::NORM_OFF << CfgBitPos::CONV_MODE) | (1 << CfgBitPos::FAULTY_STATUS_CLEAR);
+        uint8_t cfg = (Bias::OFF << CfgBitPos::BIAS_SEL) |
+                      (Wires::FOUR_WIRE << CfgBitPos::WIRE_SEL) |
+                      (ConvMode::NORM_OFF << CfgBitPos::CONV_MODE);
         result = writeCfgReg(rtd->spiCookie, cfg);
         if (result != HasReturnvaluesIF::RETURN_OK) {
           handleSpiError(rtd, result, "writeCfgReg");
@@ -84,14 +83,14 @@ bool Max31865RtdReader::periodicInitHandling() {
             handleSpiError(rtd, result, "clearFaultStatus");
           }
         }
-        someRtdOn = true;
         rtd->configured = true;
+        rtd->db.configured = true;
+        if (rtd->active) {
+          rtd->db.active = true;
+        }
       }
     }
   }
-  if (not someRtdOn) {
-    return false;
-  }
   bool someRtdUsable = false;
   for (auto& rtd : rtds) {
     if (rtd == nullptr) {
@@ -126,6 +125,10 @@ void Max31865RtdReader::periodicReadReqHandling() {
       }
       currentCfg |= (1 << CfgBitPos::ONE_SHOT);
       result = writeCfgReg(rtd->spiCookie, currentCfg);
+      if (result != RETURN_OK) {
+        handleSpiError(rtd, result, "writeCfgReg");
+        continue;
+      }
     }
   }
 }
@@ -154,7 +157,7 @@ void Max31865RtdReader::periodicReadHandling() {
       if (faultBitSet) {
         rtd->db.faultBitSet = faultBitSet;
       }
-      rtd->db.rtdVal = rtdVal;
+      rtd->db.adcCode = rtdVal;
     }
   }
   for (auto& rtd : rtds) {
@@ -182,6 +185,10 @@ ReturnValue_t Max31865RtdReader::initializeInterface(CookieIF* cookie) {
     throw std::invalid_argument("Invalid RTD index");
   }
   rtds[rtdCookie->idx] = rtdCookie;
+  MutexGuard mg(readerMutex);
+  if (dbLen == 0) {
+    dbLen = rtdCookie->db.getSerializedSize();
+  }
   return RETURN_OK;
 }
 
@@ -299,14 +306,13 @@ ReturnValue_t Max31865RtdReader::readReceivedMessage(CookieIF* cookie, uint8_t**
     return RETURN_FAILED;
   }
   *buffer = reinterpret_cast<uint8_t*>(rtdCookie->exchangeBuf.data());
-  *size = rtdCookie->db.getSerializedSize();
+  *size = serLen;
   return RETURN_OK;
 }
 
 ReturnValue_t Max31865RtdReader::writeCfgReg(SpiCookie* cookie, uint8_t cfg) {
   using namespace MAX31865;
-  uint8_t cmd = cfg;
-  return writeNToReg(cookie, CONFIG, 1, &cmd, nullptr);
+  return writeNToReg(cookie, CONFIG, 1, &cfg, nullptr);
 }
 
 ReturnValue_t Max31865RtdReader::writeBiasSel(MAX31865::Bias bias, SpiCookie* cookie) {
@@ -388,7 +394,7 @@ ReturnValue_t Max31865RtdReader::writeNToReg(SpiCookie* cookie, uint8_t reg, siz
   for (size_t idx = 0; idx < n; idx++) {
     cmdBuf[idx + 1] = cmd[idx];
   }
-  return comIF->sendMessage(cookie, cmd, 2);
+  return comIF->sendMessage(cookie, cmdBuf.data(), n + 1);
 }
 
 ReturnValue_t Max31865RtdReader::readRtdVal(SpiCookie* cookie, uint16_t& val, bool& faultBitSet) {
@@ -416,18 +422,19 @@ ReturnValue_t Max31865RtdReader::readNFromReg(SpiCookie* cookie, uint8_t reg, si
   reg &= ~WRITE_BIT;
   cmdBuf[0] = reg;
   std::memset(cmdBuf.data() + 1, 0, n);
-  ReturnValue_t result = comIF->sendMessage(cookie, cmdBuf.data(), n);
+  ReturnValue_t result = comIF->sendMessage(cookie, cmdBuf.data(), n + 1);
   if (result != RETURN_OK) {
     return RETURN_FAILED;
   }
-  uint8_t* replyPtr = replyBuf.data();
+
   size_t dummyLen = 0;
+  uint8_t* replyPtr = nullptr;
   result = comIF->readReceivedMessage(cookie, &replyPtr, &dummyLen);
   if (result != RETURN_OK) {
     return result;
   }
   if (reply != nullptr) {
-    *reply = replyBuf.data() + 1;
+    *reply = replyPtr + 1;
   }
   return RETURN_OK;
 }
diff --git a/linux/devices/Max31865RtdLowlevelHandler.h b/linux/devices/Max31865RtdLowlevelHandler.h
index 0afc25c7..4bf5d7e7 100644
--- a/linux/devices/Max31865RtdLowlevelHandler.h
+++ b/linux/devices/Max31865RtdLowlevelHandler.h
@@ -45,7 +45,7 @@ class Max31865RtdReader : public SystemObject,
  private:
   std::vector<Max31865ReaderCookie*> rtds;
   std::array<uint8_t, 4> cmdBuf = {};
-  std::array<uint8_t, 4> replyBuf = {};
+  size_t dbLen = 0;
   MutexIF* readerMutex;
 
   void rtdMainLoop();
diff --git a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp
index 05de8cf3..990e8200 100644
--- a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp
+++ b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp
@@ -5,6 +5,8 @@
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 
+#include "mission/devices/devicedefinitions/Max31865Definitions.h"
+
 #ifndef RPI_TEST_ADIS16507
 #define RPI_TEST_ADIS16507 0
 #endif
@@ -62,6 +64,7 @@ ReturnValue_t pst::pstSpiRw(FixedTimeslotTaskIF *thisSequence) {
 ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
   uint32_t length = thisSequence->getPeriodMs();
   static_cast<void>(length);
+  thisSequence->addSlot(objects::SPI_RTD_COM_IF, length * 0.0, 0);
 #if OBSW_ADD_PL_PCDU == 1
   thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
@@ -73,140 +76,26 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
 #endif
-#if OBSW_ADD_RTD_DEVICES == 1
-  thisSequence->addSlot(objects::RTD_0_IC3_PLOC_HEATSPREADER, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_1_IC4_PLOC_MISSIONBOARD, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_2_IC5_4K_CAMERA, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_3_IC6_DAC_HEATSPREADER, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_4_IC7_STARTRACKER, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_5_IC8_RW1_MX_MY, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_6_IC9_DRO, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_7_IC10_SCEX, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_8_IC11_X8, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_9_IC12_HPA, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_10_IC13_PL_TX, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_11_IC14_MPA, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_12_IC15_ACU, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_13_IC16_PLPCDU_HEATSPREADER, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_14_IC17_TCS_BOARD, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RTD_15_IC18_IMTQ, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-#endif /* OBSW_ADD_RTD_DEVICES */
 
 #if OBSW_ADD_TMP_DEVICES == 1
   thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::SEND_WRITE);
   thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::SEND_WRITE);
 #endif
-#if OBSW_ADD_RTD_DEVICES == 1
-  thisSequence->addSlot(objects::RTD_0_IC3_PLOC_HEATSPREADER, length * 0.2,
-                        DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_1_IC4_PLOC_MISSIONBOARD, length * 0.2,
-                        DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_2_IC5_4K_CAMERA, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_3_IC6_DAC_HEATSPREADER, length * 0.2,
-                        DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_4_IC7_STARTRACKER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_5_IC8_RW1_MX_MY, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_6_IC9_DRO, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_7_IC10_SCEX, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_8_IC11_X8, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_9_IC12_HPA, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_10_IC13_PL_TX, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_11_IC14_MPA, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_12_IC15_ACU, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_13_IC16_PLPCDU_HEATSPREADER, length * 0.2,
-                        DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_14_IC17_TCS_BOARD, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RTD_15_IC18_IMTQ, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-#endif /* OBSW_ADD_RTD_DEVICES */
 
 #if OBSW_ADD_TMP_DEVICES == 1
   thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.4, DeviceHandlerIF::GET_WRITE);
   thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.4, DeviceHandlerIF::GET_WRITE);
 #endif
-#if OBSW_ADD_RTD_DEVICES == 1
-  thisSequence->addSlot(objects::RTD_0_IC3_PLOC_HEATSPREADER, length * 0.4,
-                        DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_1_IC4_PLOC_MISSIONBOARD, length * 0.4,
-                        DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_2_IC5_4K_CAMERA, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_3_IC6_DAC_HEATSPREADER, length * 0.4,
-                        DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_4_IC7_STARTRACKER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_5_IC8_RW1_MX_MY, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_6_IC9_DRO, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_7_IC10_SCEX, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_8_IC11_X8, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_9_IC12_HPA, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_10_IC13_PL_TX, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_11_IC14_MPA, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_12_IC15_ACU, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_13_IC16_PLPCDU_HEATSPREADER, length * 0.4,
-                        DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_14_IC17_TCS_BOARD, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RTD_15_IC18_IMTQ, length * 0.4, DeviceHandlerIF::GET_WRITE);
-#endif /* OBSW_ADD_RTD_DEVICES */
 
 #if OBSW_ADD_TMP_DEVICES == 1
   thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.6, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.6, DeviceHandlerIF::SEND_READ);
 #endif
-#if OBSW_ADD_RTD_DEVICES == 1
-  thisSequence->addSlot(objects::RTD_0_IC3_PLOC_HEATSPREADER, length * 0.6,
-                        DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_1_IC4_PLOC_MISSIONBOARD, length * 0.6,
-                        DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_2_IC5_4K_CAMERA, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_3_IC6_DAC_HEATSPREADER, length * 0.6,
-                        DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_4_IC7_STARTRACKER, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_5_IC8_RW1_MX_MY, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_6_IC9_DRO, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_7_IC10_SCEX, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_8_IC11_X8, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_9_IC12_HPA, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_10_IC13_PL_TX, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_11_IC14_MPA, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_12_IC15_ACU, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_13_IC16_PLPCDU_HEATSPREADER, length * 0.6,
-                        DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_14_IC17_TCS_BOARD, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RTD_15_IC18_IMTQ, length * 0.6, DeviceHandlerIF::SEND_READ);
-#endif /* OBSW_ADD_RTD_DEVICES */
 
 #if OBSW_ADD_TMP_DEVICES == 1
   thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.8, DeviceHandlerIF::GET_READ);
   thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.8, DeviceHandlerIF::GET_READ);
 #endif
-#if OBSW_ADD_RTD_DEVICES == 1
-  thisSequence->addSlot(objects::RTD_0_IC3_PLOC_HEATSPREADER, length * 0.8,
-                        DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_1_IC4_PLOC_MISSIONBOARD, length * 0.8,
-                        DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_2_IC5_4K_CAMERA, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_3_IC6_DAC_HEATSPREADER, length * 0.8,
-                        DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_4_IC7_STARTRACKER, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_5_IC8_RW1_MX_MY, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_6_IC9_DRO, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_7_IC10_SCEX, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_8_IC11_X8, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_9_IC12_HPA, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_10_IC13_PL_TX, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_11_IC14_MPA, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_12_IC15_ACU, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_13_IC16_PLPCDU_HEATSPREADER, length * 0.8,
-                        DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_14_IC17_TCS_BOARD, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RTD_15_IC18_IMTQ, length * 0.8, DeviceHandlerIF::GET_READ);
-#endif /* OBSW_ADD_RTD_DEVICES */
 
 #if OBSW_ADD_RAD_SENSORS == 1
   /* Radiation sensor */
diff --git a/mission/devices/Max31865EiveHandler.cpp b/mission/devices/Max31865EiveHandler.cpp
index 193dd10c..57a1e107 100644
--- a/mission/devices/Max31865EiveHandler.cpp
+++ b/mission/devices/Max31865EiveHandler.cpp
@@ -3,7 +3,10 @@
 Max31865EiveHandler::Max31865EiveHandler(object_id_t objectId, object_id_t comIF,
                                          CookieIF* comCookie)
     : DeviceHandlerBase(objectId, comIF, comCookie, nullptr),
-      sensorDataset(this, EiveMax31855::RtdCommands::EXCHANGE_SET_ID) {}
+      sensorDataset(this, EiveMax31855::RtdCommands::EXCHANGE_SET_ID),
+      debugDivider(5) {
+  structLen = exchangeStruct.getSerializedSize();
+}
 
 void Max31865EiveHandler::doStartUp() {
   if (state == InternalState::NONE or state == InternalState::INACTIVE) {
@@ -86,21 +89,18 @@ void Max31865EiveHandler::setInstantNormal(bool instantNormal) {
   this->instantNormal = instantNormal;
 }
 
+void Max31865EiveHandler::setDebugMode(bool enable, uint32_t divider) {
+  this->debugMode = enable;
+  debugDivider.setDivider(divider);
+}
+
 void Max31865EiveHandler::simpleCommand(EiveMax31855::RtdCommands cmd) {
   cmdBuf[0] = static_cast<uint8_t>(cmd);
   rawPacket = cmdBuf.data();
   rawPacketLen = 1;
 }
 void Max31865EiveHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
-  if (mode == _MODE_TO_NORMAL) {
-    state = InternalState::ACTIVE;
-    transitionOk = false;
-    if (transitionOk) {
-      setMode(MODE_NORMAL);
-    }
-  } else {
-    DeviceHandlerBase::doTransition(modeFrom, subModeFrom);
-  }
+  DeviceHandlerBase::doTransition(modeFrom, subModeFrom);
 }
 
 void Max31865EiveHandler::fillCommandAndReplyMap() {
@@ -112,20 +112,42 @@ void Max31865EiveHandler::fillCommandAndReplyMap() {
 
 ReturnValue_t Max31865EiveHandler::scanForReply(const uint8_t* start, size_t remainingSize,
                                                 DeviceCommandId_t* foundId, size_t* foundLen) {
-  if (remainingSize != exchangeStruct.getSerializedSize()) {
+  if (remainingSize != structLen) {
     sif::error << "Invalid reply from RTD reader detected, reply size " << remainingSize
-               << "not equal to exchange struct size" << exchangeStruct.getSerializedSize()
-               << std::endl;
-    return RETURN_FAILED;
+               << " not equal to exchange struct size " << structLen << std::endl;
+    return DeviceHandlerIF::INVALID_DATA;
   }
   *foundId = EiveMax31855::RtdCommands::EXCHANGE_SET_ID;
   *foundLen = remainingSize;
-  sif::info << "Max31865EiveHandler::scanForReply: Reply size " << remainingSize << std::endl;
   return RETURN_OK;
 }
 
 ReturnValue_t Max31865EiveHandler::interpretDeviceReply(DeviceCommandId_t id,
                                                         const uint8_t* packet) {
+  size_t deserTmp = structLen;
+  auto result = exchangeStruct.deSerialize(&packet, &deserTmp, SerializeIF::Endianness::MACHINE);
+  if (result != RETURN_OK) {
+    return result;
+  }
+  if (mode == _MODE_START_UP) {
+    if (exchangeStruct.active and state == InternalState::ACTIVE) {
+      transitionOk = true;
+    }
+    if (exchangeStruct.configured and state == InternalState::ON) {
+      transitionOk = true;
+    }
+  }
+  // Calculate resistance
+  float rtdValue = exchangeStruct.adcCode * EiveMax31855::RTD_RREF_PT1000 / INT16_MAX;
+  // calculate approximation
+  float approxTemp = exchangeStruct.adcCode / 32.0 - 256.0;
+
+  if (debugMode) {
+    if (debugDivider.checkAndIncrement()) {
+      sif::info << "Max31865: " << std::setw(20) << std::left << locString << std::right
+                << " | R[Ohm] " << rtdValue << " Ohms | Approx T[C]: " << approxTemp << std::endl;
+    }
+  }
   return RETURN_OK;
 }
 
@@ -148,7 +170,7 @@ void Max31865EiveHandler::setDeviceInfo(uint8_t idx_, std::string location_) {
 
 ReturnValue_t Max31865EiveHandler::initialize() {
   auto result = DeviceHandlerBase::initialize();
-  if(result != RETURN_OK) {
+  if (result != RETURN_OK) {
     return result;
   }
   return updatePeriodicReply(true, EiveMax31855::RtdCommands::EXCHANGE_SET_ID);
diff --git a/mission/devices/Max31865EiveHandler.h b/mission/devices/Max31865EiveHandler.h
index 07bf7938..121929e7 100644
--- a/mission/devices/Max31865EiveHandler.h
+++ b/mission/devices/Max31865EiveHandler.h
@@ -2,6 +2,7 @@
 #define MISSION_DEVICES_MAX31865EIVEHANDLER_H_
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <fsfw/globalfunctions/PeriodicOperationDivider.h>
 
 #include "devicedefinitions/Max31865Definitions.h"
 
@@ -9,6 +10,7 @@ class Max31865EiveHandler : public DeviceHandlerBase {
  public:
   Max31865EiveHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie);
   void setInstantNormal(bool instantNormal);
+  void setDebugMode(bool enable, uint32_t divider);
   void setDeviceInfo(uint8_t idx, std::string location);
 
  private:
@@ -33,8 +35,11 @@ class Max31865EiveHandler : public DeviceHandlerBase {
   uint8_t idx = 0;
   std::string locString = "Unknown";
   EiveMax31855::ReadOutStruct exchangeStruct;
+  bool debugMode = false;
+  size_t structLen = 0;
   bool instantNormal = false;
   MAX31865::Max31865Set sensorDataset;
+  PeriodicOperationDivider debugDivider;
   enum class InternalState { NONE, ON, ACTIVE, INACTIVE } state = InternalState::NONE;
   bool transitionOk = false;
 };
diff --git a/mission/devices/Max31865PT1000Handler.cpp b/mission/devices/Max31865PT1000Handler.cpp
index b9d163e9..354fe1c5 100644
--- a/mission/devices/Max31865PT1000Handler.cpp
+++ b/mission/devices/Max31865PT1000Handler.cpp
@@ -394,9 +394,8 @@ ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(DeviceCommandId_t id,
       // RTD value consists of last seven bits of the LSB reply byte and
       // the MSB reply byte
       uint16_t adcCode = ((packet[1] << 8) | packet[2]) >> 1;
-      // do something with rtd value, will propably be stored in
-      // dataset.
-      float rtdValue = adcCode * RTD_RREF_PT1000 / INT16_MAX;
+      // Calculate resistance
+      float rtdValue = adcCode * EiveMax31855::RTD_RREF_PT1000 / INT16_MAX;
       // calculate approximation
       float approxTemp = adcCode / 32.0 - 256.0;
 
diff --git a/mission/devices/Max31865PT1000Handler.h b/mission/devices/Max31865PT1000Handler.h
index bdf22213..6b136f13 100644
--- a/mission/devices/Max31865PT1000Handler.h
+++ b/mission/devices/Max31865PT1000Handler.h
@@ -61,7 +61,6 @@ class Max31865PT1000Handler : public DeviceHandlerBase {
   static constexpr uint16_t HIGH_THRESHOLD = 11298;  // = 100 C
   static constexpr uint16_t LOW_THRESHOLD = 4902;    // = -100 C
 
-  static constexpr float RTD_RREF_PT1000 = 4020.0;         //!< Ohm
   static constexpr float RTD_RESISTANCE0_PT1000 = 1000.0;  //!< Ohm
  protected:
   // DeviceHandlerBase abstract function implementation
diff --git a/mission/devices/devicedefinitions/Max31865Definitions.h b/mission/devices/devicedefinitions/Max31865Definitions.h
index 9f54a322..d9942907 100644
--- a/mission/devices/devicedefinitions/Max31865Definitions.h
+++ b/mission/devices/devicedefinitions/Max31865Definitions.h
@@ -14,7 +14,7 @@ enum Wires : unsigned int { TWO_WIRE = 0, THREE_WIRE = 1, FOUR_WIRE = 0 };
 
 enum ConvMode : unsigned int { NORM_OFF = 0, AUTO = 1 };
 
-enum Bias : unsigned int { ON = 0, OFF = 1 };
+enum Bias : unsigned int { OFF = 0, ON = 1 };
 
 enum FilterSel : unsigned int { FIFTY_HERTZ = 1, SIXTY_HERTZ = 0 };
 
@@ -85,6 +85,7 @@ class Max31865Set : public StaticLocalDataSet<4> {
 
 namespace EiveMax31855 {
 
+static constexpr float RTD_RREF_PT1000 = 4020.0;  //!< Ohm
 static constexpr uint8_t NUM_RTDS = 16;
 
 enum RtdCommands : DeviceCommandId_t {
@@ -104,24 +105,28 @@ class ReadOutStruct : public SerialLinkedListAdapter<SerializeIF> {
   ReadOutStruct(bool active, uint32_t spiErrCnt, bool faultBitSet, uint8_t faultVal,
                 uint16_t rtdVal)
       : active(active),
-        rtdVal(rtdVal),
+        adcCode(rtdVal),
         faultBitSet(faultBitSet),
         faultValue(faultVal),
         spiErrorCount(spiErrCnt) {
     setLinks();
   }
 
+  //! RTD was set on and is configured, but is not periodically polled
+  SerializeElement<bool> configured = false;
+  //! RTD is active and polled periodically
   SerializeElement<bool> active = false;
-  SerializeElement<uint16_t> rtdVal = 0;
+  SerializeElement<uint16_t> adcCode = 0;
   SerializeElement<bool> faultBitSet = false;
   SerializeElement<uint8_t> faultValue = 0;
   SerializeElement<uint32_t> spiErrorCount = 0;
 
  private:
   void setLinks() {
-    setStart(&active);
-    active.setNext(&rtdVal);
-    rtdVal.setNext(&faultBitSet);
+    setStart(&configured);
+    configured.setNext(&active);
+    active.setNext(&adcCode);
+    adcCode.setNext(&faultBitSet);
     faultBitSet.setNext(&faultValue);
     faultValue.setNext(&spiErrorCount);
   };