diff --git a/CHANGELOG.md b/CHANGELOG.md
index c33e49f5..8841cd0c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -33,6 +33,10 @@ will consitute of a breaking change warranting a new major release:
   CMake from selecting wrong cross-compilers if multiple cross-compilers with the same name are used
   on the same system.
 - Add ACS board for EM by default now.
+- Add support for MPSoC HK packet.
+- Add support for MPSoC Flash Directory Content Report.
+- Dynamically enable and disable HK packets for MPSoC on `ON` and `OFF` commands.
+- Increase frequency of payload handlers from 0.8 seconds to 0.5 seconds.
 
 ## Added
 
@@ -50,6 +54,8 @@ will consitute of a breaking change warranting a new major release:
   without an additional PCDU power switch command.
 - The PLOC Supervisor handler now waits for the replies to the `SET_TIME` command to verify working
   communication.
+- The PLOC MPSoC now waits 10 cycles before going to on. These wait cycles are necessary because
+  the MPSoC is not ready to process commands without this additional boot time.
 - Fixed correction for `GPS Altitude` in case the sensor data is out of the expected bonds.
 
 # [v2.0.5] 2023-05-11
diff --git a/bsp_q7s/core/scheduling.cpp b/bsp_q7s/core/scheduling.cpp
index f2cd8229..5866ce8c 100644
--- a/bsp_q7s/core/scheduling.cpp
+++ b/bsp_q7s/core/scheduling.cpp
@@ -366,7 +366,7 @@ void scheduling::initTasks() {
 #endif /* OBSW_ADD_PLOC_SUPERVISOR */
 
   PeriodicTaskIF* plTask = factory->createPeriodicTask(
-      "PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc, &RR_SCHEDULING);
+      "PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc, &RR_SCHEDULING);
   plTask->addComponent(objects::CAM_SWITCHER);
   scheduling::addMpsocSupvHandlers(plTask);
   scheduling::scheduleScexDev(plTask);
diff --git a/linux/payload/PlocMpsocHandler.cpp b/linux/payload/PlocMpsocHandler.cpp
index 72f2355f..07f7759d 100644
--- a/linux/payload/PlocMpsocHandler.cpp
+++ b/linux/payload/PlocMpsocHandler.cpp
@@ -1,3 +1,4 @@
+#include <fsfw/globalfunctions/arrayprinter.h>
 #include <linux/payload/PlocMpsocHandler.h>
 #include <linux/payload/plocSupvDefs.h>
 
@@ -11,6 +12,7 @@ PlocMPSoCHandler::PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid
                                    CookieIF* comCookie, PlocMPSoCHelper* plocMPSoCHelper,
                                    Gpio uartIsolatorSwitch, object_id_t supervisorHandler)
     : DeviceHandlerBase(objectId, uartComIFid, comCookie),
+      hkReport(this),
       plocMPSoCHelper(plocMPSoCHelper),
       uartIsolatorSwitch(uartIsolatorSwitch),
       supervisorHandler(supervisorHandler),
@@ -103,6 +105,7 @@ void PlocMPSoCHandler::performOperationHook() {
 ReturnValue_t PlocMPSoCHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                                               const uint8_t* data, size_t size) {
   ReturnValue_t result = returnvalue::OK;
+  commandIsPending = true;
   switch (actionId) {
     case mpsoc::SET_UART_TX_TRISTATE: {
       uartIsolatorSwitch.pullLow();
@@ -151,29 +154,47 @@ ReturnValue_t PlocMPSoCHandler::executeAction(ActionId_t actionId, MessageQueueI
 }
 
 void PlocMPSoCHandler::doStartUp() {
+  if (startupState == StartupState::IDLE) {
+    startupState = StartupState::HW_INIT;
+  }
+  if (startupState == StartupState::HW_INIT) {
 #ifdef XIPHOS_Q7S
 #if not OBSW_MPSOC_JTAG_BOOT == 1
-  switch (powerState) {
-    case PowerState::OFF:
-      commandActionHelper.commandAction(supervisorHandler, supv::START_MPSOC);
-      powerState = PowerState::BOOTING;
-      break;
-    case PowerState::ON:
-      setMode(_MODE_TO_ON);
-      uartIsolatorSwitch.pullHigh();
-      break;
-    default:
-      break;
-  }
+    switch (powerState) {
+      case PowerState::OFF:
+        commandActionHelper.commandAction(supervisorHandler, supv::START_MPSOC);
+        powerState = PowerState::BOOTING;
+        return;
+      case PowerState::ON:
+        uartIsolatorSwitch.pullHigh();
+        startupState = StartupState::WAIT_CYCLES;
+        break;
+      default:
+        return;
+    }
 #else
-  powerState = PowerState::ON;
-  setMode(_MODE_TO_ON);
-  uartIsolatorSwitch.pullHigh();
+    uartIsolatorSwitch.pullHigh();
+    startupState = StartupState::WAIT_CYCLES;
 #endif /* not MSPOC_JTAG_BOOT == 1 */
 #else
-  powerState = PowerState::ON;
-  setMode(_MODE_TO_ON);
+    startupState = StartupState::WAIT_CYCLES;
+    powerState = PowerState::ON;
 #endif /* XIPHOS_Q7S */
+  }
+  // Need to wait, MPSoC still not booted properly, requesting HK without these wait cycles does
+  // not work, no replies..
+  if (startupState == StartupState::WAIT_CYCLES) {
+    waitCycles++;
+    if (waitCycles >= 8) {
+      startupState = StartupState::DONE;
+      waitCycles = 0;
+    }
+  }
+  if (startupState == StartupState::DONE) {
+    setMode(_MODE_TO_ON);
+    hkReport.setReportingEnabled(true);
+    startupState = StartupState::IDLE;
+  }
 }
 
 void PlocMPSoCHandler::doShutDown() {
@@ -187,6 +208,7 @@ void PlocMPSoCHandler::doShutDown() {
       break;
     case PowerState::OFF:
       sequenceCount = 0;
+      hkReport.setReportingEnabled(false);
       setMode(_MODE_POWER_DOWN);
       break;
     default:
@@ -195,13 +217,20 @@ void PlocMPSoCHandler::doShutDown() {
 #else
   sequenceCount = 0;
   uartIsolatorSwitch.pullLow();
+  hkReport.setReportingEnabled(false);
   setMode(_MODE_POWER_DOWN);
   powerState = PowerState::OFF;
 #endif
 #endif
+  startupState = StartupState::IDLE;
 }
 
 ReturnValue_t PlocMPSoCHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
+  if (not commandIsPending) {
+    *id = mpsoc::TC_GET_HK_REPORT;
+    commandIsPending = true;
+    return buildCommandFromCommand(*id, nullptr, 0);
+  }
   return NOTHING_TO_SEND;
 }
 
@@ -247,6 +276,14 @@ ReturnValue_t PlocMPSoCHandler::buildCommandFromCommand(DeviceCommandId_t device
       result = prepareTcReplayWriteSequence(commandData, commandDataLen);
       break;
     }
+    case (mpsoc::TC_GET_HK_REPORT): {
+      result = prepareTcGetHkReport();
+      break;
+    }
+    case (mpsoc::TC_FLASH_GET_DIRECTORY_CONTENT): {
+      result = prepareTcGetDirContent(commandData, commandDataLen);
+      break;
+    }
     case (mpsoc::TC_MODE_REPLAY): {
       result = prepareTcModeReplay();
       break;
@@ -304,16 +341,20 @@ void PlocMPSoCHandler::fillCommandAndReplyMap() {
   this->insertInCommandMap(mpsoc::TC_MODE_REPLAY);
   this->insertInCommandMap(mpsoc::TC_MODE_IDLE);
   this->insertInCommandMap(mpsoc::TC_CAM_CMD_SEND);
+  this->insertInCommandMap(mpsoc::TC_GET_HK_REPORT);
   this->insertInCommandMap(mpsoc::RELEASE_UART_TX);
   this->insertInCommandMap(mpsoc::SET_UART_TX_TRISTATE);
   this->insertInCommandMap(mpsoc::TC_CAM_TAKE_PIC);
+  this->insertInCommandMap(mpsoc::TC_FLASH_GET_DIRECTORY_CONTENT);
   this->insertInCommandMap(mpsoc::TC_SIMPLEX_SEND_FILE);
   this->insertInCommandMap(mpsoc::TC_DOWNLINK_DATA_MODULATE);
   this->insertInCommandMap(mpsoc::TC_MODE_SNAPSHOT);
   this->insertInReplyMap(mpsoc::ACK_REPORT, 3, nullptr, mpsoc::SIZE_ACK_REPORT);
   this->insertInReplyMap(mpsoc::EXE_REPORT, 3, nullptr, mpsoc::SIZE_EXE_REPORT);
   this->insertInReplyMap(mpsoc::TM_MEMORY_READ_REPORT, 2, nullptr, mpsoc::SIZE_TM_MEM_READ_REPORT);
+  this->insertInReplyMap(mpsoc::TM_GET_HK_REPORT, 5, nullptr, mpsoc::SIZE_TM_HK_REPORT);
   this->insertInReplyMap(mpsoc::TM_CAM_CMD_RPT, 2, nullptr, mpsoc::SP_MAX_SIZE);
+  this->insertInReplyMap(mpsoc::TM_FLASH_DIRECTORY_CONTENT, 2, nullptr, mpsoc::SP_MAX_SIZE);
 }
 
 ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remainingSize,
@@ -331,6 +372,11 @@ ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remain
   }
   uint16_t apid = spacePacket.getApid();
 
+  auto handleDedicatedReply = [&](DeviceCommandId_t replyId) {
+    *foundLen = spacePacket.getFullPacketLen();
+    foundPacketLen = *foundLen;
+    *foundId = replyId;
+  };
   switch (apid) {
     case (mpsoc::apid::ACK_SUCCESS):
       *foundLen = mpsoc::SIZE_ACK_REPORT;
@@ -345,10 +391,16 @@ ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remain
       *foundId = mpsoc::TM_MEMORY_READ_REPORT;
       break;
     case (mpsoc::apid::TM_CAM_CMD_RPT):
-      *foundLen = spacePacket.getFullPacketLen();
-      tmCamCmdRpt.rememberSpacePacketSize = *foundLen;
-      *foundId = mpsoc::TM_CAM_CMD_RPT;
+      handleDedicatedReply(mpsoc::TM_CAM_CMD_RPT);
       break;
+    case (mpsoc::apid::TM_HK_GET_REPORT): {
+      handleDedicatedReply(mpsoc::TM_GET_HK_REPORT);
+      break;
+    }
+    case (mpsoc::apid::TM_FLASH_DIRECTORY_CONTENT): {
+      handleDedicatedReply(mpsoc::TM_FLASH_DIRECTORY_CONTENT);
+      break;
+    }
     case (mpsoc::apid::EXE_SUCCESS):
       *foundLen = mpsoc::SIZE_EXE_REPORT;
       *foundId = mpsoc::EXE_REPORT;
@@ -358,13 +410,14 @@ ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remain
       *foundId = mpsoc::EXE_REPORT;
       break;
     default: {
-      sif::debug << "PlocMPSoCHandler::scanForReply: Reply has invalid apid" << std::endl;
+      sif::debug << "PlocMPSoCHandler::scanForReply: Reply has invalid APID 0x" << std::hex
+                 << std::setfill('0') << std::setw(2) << apid << std::dec << std::endl;
       *foundLen = remainingSize;
       return MPSoCReturnValuesIF::INVALID_APID;
     }
   }
 
-  uint16_t recvSeqCnt = (*(start + 2) << 8 | *(start + 3)) & PACKET_SEQUENCE_COUNT_MASK;
+  uint16_t recvSeqCnt = ((*(start + 2) << 8) | *(start + 3)) & PACKET_SEQUENCE_COUNT_MASK;
   if (recvSeqCnt != sequenceCount) {
     triggerEvent(MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH, sequenceCount, recvSeqCnt);
     sequenceCount = recvSeqCnt;
@@ -386,10 +439,26 @@ ReturnValue_t PlocMPSoCHandler::interpretDeviceReply(DeviceCommandId_t id, const
       result = handleMemoryReadReport(packet);
       break;
     }
+    case (mpsoc::TM_GET_HK_REPORT): {
+      result = handleGetHkReport(packet);
+      break;
+    }
     case (mpsoc::TM_CAM_CMD_RPT): {
       result = handleCamCmdRpt(packet);
       break;
     }
+    case (mpsoc::TM_FLASH_DIRECTORY_CONTENT): {
+      result = verifyPacket(packet, foundPacketLen);
+      if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
+        sif::warning << "PLOC MPSoC: Flash directory content reply invalid CRC" << std::endl;
+      }
+      /** Send data to commanding queue */
+      handleDeviceTm(packet + mpsoc::DATA_FIELD_OFFSET,
+                     foundPacketLen - mpsoc::DATA_FIELD_OFFSET - mpsoc::CRC_SIZE,
+                     mpsoc::TM_FLASH_DIRECTORY_CONTENT);
+      nextReplyId = mpsoc::EXE_REPORT;
+      return result;
+    }
     case (mpsoc::EXE_REPORT): {
       result = handleExecutionReport(packet);
       break;
@@ -403,12 +472,51 @@ ReturnValue_t PlocMPSoCHandler::interpretDeviceReply(DeviceCommandId_t id, const
   return result;
 }
 
-void PlocMPSoCHandler::setNormalDatapoolEntriesInvalid() {}
+void PlocMPSoCHandler::setNormalDatapoolEntriesInvalid() {
+  PoolReadGuard pg(&hkReport);
+  hkReport.setValidity(false, true);
+}
 
-uint32_t PlocMPSoCHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 5000; }
+uint32_t PlocMPSoCHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 10000; }
 
 ReturnValue_t PlocMPSoCHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                         LocalDataPoolManager& poolManager) {
+  localDataPoolMap.emplace(mpsoc::poolid::STATUS, &peStatus);
+  localDataPoolMap.emplace(mpsoc::poolid::MODE, &peMode);
+  localDataPoolMap.emplace(mpsoc::poolid::DOWNLINK_PWR_ON, &peDownlinkPwrOn);
+  localDataPoolMap.emplace(mpsoc::poolid::DOWNLINK_REPLY_ACTIIVE, &peDownlinkReplyActive);
+  localDataPoolMap.emplace(mpsoc::poolid::DOWNLINK_JESD_SYNC_STATUS, &peDownlinkJesdSyncStatus);
+  localDataPoolMap.emplace(mpsoc::poolid::DOWNLINK_DAC_STATUS, &peDownlinkDacStatus);
+  localDataPoolMap.emplace(mpsoc::poolid::CAM_STATUS, &peCameraStatus);
+  localDataPoolMap.emplace(mpsoc::poolid::CAM_SDI_STATUS, &peCameraSdiStatus);
+  localDataPoolMap.emplace(mpsoc::poolid::CAM_FPGA_TEMP, &peCameraFpgaTemp);
+  localDataPoolMap.emplace(mpsoc::poolid::CAM_SOC_TEMP, &peCameraSocTemp);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_TEMP, &peSysmonTemp);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCINT, &peSysmonVccInt);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCAUX, &peSysmonVccAux);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCBRAM, &peSysmonVccBram);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCPAUX, &peSysmonVccPaux);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCPINT, &peSysmonVccPint);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCCPDRO, &peSysmonVccPdro);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_MB12V, &peSysmonMb12V);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_MB3V3, &peSysmonMb3V3);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_MB1V8, &peSysmonMb1V8);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC12V, &peSysmonVcc12V);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC5V, &peSysmonVcc5V);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC3V3, &peSysmonVcc3V3);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC3V3VA, &peSysmonVcc3V3VA);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC2V5DDR, &peSysmonVcc2V5DDR);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC1V2DDR, &peSysmonVcc1V2DDR);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC0V9, &peSysmonVcc0V9);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_VCC0V6VTT, &peSysmonVcc0V6VTT);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_SAFE_COTS_CUR, &peSysmonSafeCotsCur);
+  localDataPoolMap.emplace(mpsoc::poolid::SYSMON_NVM4_XO_CUR, &peSysmonNvm4XoCur);
+  localDataPoolMap.emplace(mpsoc::poolid::SEM_UNCORRECTABLE_ERRS, &peSemUncorrectableErrs);
+  localDataPoolMap.emplace(mpsoc::poolid::SEM_CORRECTABLE_ERRS, &peSemCorrectableErrs);
+  localDataPoolMap.emplace(mpsoc::poolid::SEM_STATUS, &peSemStatus);
+  localDataPoolMap.emplace(mpsoc::poolid::REBOOT_MPSOC_REQUIRED, &peRebootMpsocRequired);
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(hkReport.getSid(), false, 10.0));
   return returnvalue::OK;
 }
 
@@ -512,6 +620,16 @@ ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOff() {
   return returnvalue::OK;
 }
 
+ReturnValue_t PlocMPSoCHandler::prepareTcGetHkReport() {
+  mpsoc::TcGetHkReport tcGetHkReport(spParams, sequenceCount);
+  ReturnValue_t result = tcGetHkReport.buildPacket();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  finishTcPrep(tcGetHkReport.getFullPacketLen());
+  return returnvalue::OK;
+}
+
 ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* commandData,
                                                              size_t commandDataLen) {
   ReturnValue_t result = returnvalue::OK;
@@ -561,9 +679,8 @@ ReturnValue_t PlocMPSoCHandler::prepareTcCamCmdSend(const uint8_t* commandData,
 
 ReturnValue_t PlocMPSoCHandler::prepareTcCamTakePic(const uint8_t* commandData,
                                                     size_t commandDataLen) {
-  ReturnValue_t result = returnvalue::OK;
   mpsoc::TcCamTakePic tcCamTakePic(spParams, sequenceCount);
-  result = tcCamTakePic.buildPacket(commandData, commandDataLen);
+  ReturnValue_t result = tcCamTakePic.buildPacket(commandData, commandDataLen);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -573,9 +690,8 @@ ReturnValue_t PlocMPSoCHandler::prepareTcCamTakePic(const uint8_t* commandData,
 
 ReturnValue_t PlocMPSoCHandler::prepareTcSimplexSendFile(const uint8_t* commandData,
                                                          size_t commandDataLen) {
-  ReturnValue_t result = returnvalue::OK;
   mpsoc::TcSimplexSendFile tcSimplexSendFile(spParams, sequenceCount);
-  result = tcSimplexSendFile.buildPacket(commandData, commandDataLen);
+  ReturnValue_t result = tcSimplexSendFile.buildPacket(commandData, commandDataLen);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -583,11 +699,21 @@ ReturnValue_t PlocMPSoCHandler::prepareTcSimplexSendFile(const uint8_t* commandD
   return returnvalue::OK;
 }
 
+ReturnValue_t PlocMPSoCHandler::prepareTcGetDirContent(const uint8_t* commandData,
+                                                       size_t commandDataLen) {
+  mpsoc::TcGetDirContent tcGetDirContent(spParams, sequenceCount);
+  ReturnValue_t result = tcGetDirContent.buildPacket(commandData, commandDataLen);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  finishTcPrep(tcGetDirContent.getFullPacketLen());
+  return returnvalue::OK;
+}
+
 ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkDataModulate(const uint8_t* commandData,
                                                               size_t commandDataLen) {
-  ReturnValue_t result = returnvalue::OK;
   mpsoc::TcDownlinkDataModulate tcDownlinkDataModulate(spParams, sequenceCount);
-  result = tcDownlinkDataModulate.buildPacket(commandData, commandDataLen);
+  ReturnValue_t result = tcDownlinkDataModulate.buildPacket(commandData, commandDataLen);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -596,9 +722,8 @@ ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkDataModulate(const uint8_t* com
 }
 
 ReturnValue_t PlocMPSoCHandler::prepareTcModeSnapshot() {
-  ReturnValue_t result = returnvalue::OK;
   mpsoc::TcModeSnapshot tcModeSnapshot(spParams, sequenceCount);
-  result = tcModeSnapshot.buildPacket();
+  ReturnValue_t result = tcModeSnapshot.buildPacket();
   if (result != returnvalue::OK) {
     return result;
   }
@@ -677,8 +802,23 @@ ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) {
 
   uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK;
 
+  auto cmdDoneHandler = [&](bool success) {
+    if (normalCmdPending) {
+      normalCmdPending = false;
+    }
+    commandIsPending = false;
+    auto commandIter = deviceCommandMap.find(getPendingCommand());
+    if (commandIter != deviceCommandMap.end()) {
+      commandIter->second.isExecuting = false;
+      if (commandIter->second.sendReplyTo != MessageQueueIF::NO_QUEUE) {
+        actionHelper.finish(success, commandIter->second.sendReplyTo, getPendingCommand(), result);
+      }
+    }
+    disableAllReplies();
+  };
   switch (apid) {
     case (mpsoc::apid::EXE_SUCCESS): {
+      cmdDoneHandler(true);
       break;
     }
     case (mpsoc::apid::EXE_FAILURE): {
@@ -694,8 +834,8 @@ ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) {
       }
       printStatus(data);
       sendFailureReport(mpsoc::EXE_REPORT, MPSoCReturnValuesIF::RECEIVED_EXE_FAILURE);
-      disableExeReportReply();
       result = IGNORE_REPLY_DATA;
+      cmdDoneHandler(false);
       break;
     }
     default: {
@@ -718,30 +858,206 @@ ReturnValue_t PlocMPSoCHandler::handleMemoryReadReport(const uint8_t* data) {
   uint16_t memLen =
       *(data + mpsoc::MEM_READ_RPT_LEN_OFFSET) << 8 | *(data + mpsoc::MEM_READ_RPT_LEN_OFFSET + 1);
   /** Send data to commanding queue */
-  handleDeviceTM(data + mpsoc::DATA_FIELD_OFFSET, mpsoc::SIZE_MEM_READ_RPT_FIX + memLen * 4,
+  handleDeviceTm(data + mpsoc::DATA_FIELD_OFFSET, mpsoc::SIZE_MEM_READ_RPT_FIX + memLen * 4,
                  mpsoc::TM_MEMORY_READ_REPORT);
   nextReplyId = mpsoc::EXE_REPORT;
   return result;
 }
 
+ReturnValue_t PlocMPSoCHandler::handleGetHkReport(const uint8_t* data) {
+  ReturnValue_t result = verifyPacket(data, foundPacketLen);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  SpacePacketReader packetReader(data, foundPacketLen);
+  const uint8_t* dataStart = data + 6;
+  PoolReadGuard pg(&hkReport);
+  size_t deserLen = mpsoc::SIZE_TM_HK_REPORT;
+  SerializeIF::Endianness endianness = SerializeIF::Endianness::NETWORK;
+  result = SerializeAdapter::deSerialize(&hkReport.status.value, &dataStart, &deserLen, endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.mode.value, &dataStart, &deserLen, endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.downlinkPwrOn.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.downlinkReplyActive.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.downlinkJesdSyncStatus.value, &dataStart,
+                                         &deserLen, endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.downlinkDacStatus.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result =
+      SerializeAdapter::deSerialize(&hkReport.camStatus.value, &dataStart, &deserLen, endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.camSdiStatus.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result =
+      SerializeAdapter::deSerialize(&hkReport.camFpgaTemp.value, &dataStart, &deserLen, endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result =
+      SerializeAdapter::deSerialize(&hkReport.sysmonTemp.value, &dataStart, &deserLen, endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonVccInt.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonVccAux.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonVccBram.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonVccPaux.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonVccPint.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonVccPdro.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result =
+      SerializeAdapter::deSerialize(&hkReport.sysmonMb12V.value, &dataStart, &deserLen, endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result =
+      SerializeAdapter::deSerialize(&hkReport.sysmonMb3V3.value, &dataStart, &deserLen, endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result =
+      SerializeAdapter::deSerialize(&hkReport.sysmonMb1V8.value, &dataStart, &deserLen, endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonVcc12V.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result =
+      SerializeAdapter::deSerialize(&hkReport.sysmonVcc5V.value, &dataStart, &deserLen, endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonVcc3V3.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonVcc3V3VA.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonVcc2V5DDR.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonVcc1V2DDR.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonVcc0V9.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonVcc0V6VTT.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonSafeCotsCur.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.sysmonNvm4XoCur.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.semUncorrectableErrs.value, &dataStart,
+                                         &deserLen, endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&hkReport.semCorrectableErrs.value, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result =
+      SerializeAdapter::deSerialize(&hkReport.semStatus.value, &dataStart, &deserLen, endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  // Skip the weird filename
+  dataStart += 256;
+  result = SerializeAdapter::deSerialize(&hkReport.rebootMpsocRequired, &dataStart, &deserLen,
+                                         endianness);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return returnvalue::OK;
+}
+
 ReturnValue_t PlocMPSoCHandler::handleCamCmdRpt(const uint8_t* data) {
-  ReturnValue_t result = returnvalue::OK;
-  result = verifyPacket(data, tmCamCmdRpt.rememberSpacePacketSize);
+  ReturnValue_t result = verifyPacket(data, foundPacketLen);
   if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
     sif::warning << "PlocMPSoCHandler::handleCamCmdRpt: CRC failure" << std::endl;
   }
-  SpacePacketReader packetReader(data, tmCamCmdRpt.rememberSpacePacketSize);
+  SpacePacketReader packetReader(data, foundPacketLen);
   const uint8_t* dataFieldPtr = data + mpsoc::SPACE_PACKET_HEADER_SIZE + sizeof(uint16_t);
-  std::string camCmdRptMsg(
-      reinterpret_cast<const char*>(dataFieldPtr),
-      tmCamCmdRpt.rememberSpacePacketSize - mpsoc::SPACE_PACKET_HEADER_SIZE - sizeof(uint16_t) - 3);
+  std::string camCmdRptMsg(reinterpret_cast<const char*>(dataFieldPtr),
+                           foundPacketLen - mpsoc::SPACE_PACKET_HEADER_SIZE - sizeof(uint16_t) - 3);
 #if OBSW_DEBUG_PLOC_MPSOC == 1
   uint8_t ackValue = *(packetReader.getFullData() + packetReader.getFullPacketLen() - 2);
   sif::info << "PlocMPSoCHandler: CamCmdRpt message: " << camCmdRptMsg << std::endl;
   sif::info << "PlocMPSoCHandler: CamCmdRpt Ack value: 0x" << std::hex
             << static_cast<unsigned int>(ackValue) << std::endl;
 #endif /* OBSW_DEBUG_PLOC_MPSOC == 1 */
-  handleDeviceTM(packetReader.getPacketData() + sizeof(uint16_t),
+  handleDeviceTm(packetReader.getPacketData() + sizeof(uint16_t),
                  packetReader.getPacketDataLen() - 1, mpsoc::TM_CAM_CMD_RPT);
   return result;
 }
@@ -753,6 +1069,16 @@ ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator
 
   uint8_t enabledReplies = 0;
 
+  auto enableThreeReplies = [&](DeviceCommandId_t replyId) {
+    enabledReplies = 3;
+    result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, replyId);
+    if (result != returnvalue::OK) {
+      sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id "
+                 << mpsoc::TM_MEMORY_READ_REPORT << " not in replyMap" << std::endl;
+      return result;
+    }
+    return returnvalue::OK;
+  };
   switch (command->first) {
     case mpsoc::TC_MEM_WRITE:
     case mpsoc::TC_FLASHDELETE:
@@ -769,24 +1095,30 @@ ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator
     case mpsoc::TC_MODE_SNAPSHOT:
       enabledReplies = 2;
       break;
-    case mpsoc::TC_MEM_READ: {
-      enabledReplies = 3;
-      result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
-                                                        mpsoc::TM_MEMORY_READ_REPORT);
+    case mpsoc::TC_GET_HK_REPORT: {
+      result = enableThreeReplies(mpsoc::TM_GET_HK_REPORT);
+      if (result != returnvalue::OK) {
+        return result;
+      }
+      break;
+    }
+    case mpsoc::TC_MEM_READ: {
+      result = enableThreeReplies(mpsoc::TM_MEMORY_READ_REPORT);
       if (result != returnvalue::OK) {
-        sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id "
-                   << mpsoc::TM_MEMORY_READ_REPORT << " not in replyMap" << std::endl;
         return result;
       }
       break;
     }
     case mpsoc::TC_CAM_CMD_SEND: {
-      enabledReplies = 3;
-      result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
-                                                        mpsoc::TM_CAM_CMD_RPT);
+      result = enableThreeReplies(mpsoc::TM_CAM_CMD_RPT);
+      if (result != returnvalue::OK) {
+        return result;
+      }
+      break;
+    }
+    case mpsoc::TC_FLASH_GET_DIRECTORY_CONTENT: {
+      result = enableThreeReplies(mpsoc::TM_FLASH_DIRECTORY_CONTENT);
       if (result != returnvalue::OK) {
-        sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id "
-                   << mpsoc::TM_CAM_CMD_RPT << " not in replyMap" << std::endl;
         return result;
       }
       break;
@@ -851,12 +1183,21 @@ void PlocMPSoCHandler::setNextReplyId() {
     case mpsoc::TC_MEM_READ:
       nextReplyId = mpsoc::TM_MEMORY_READ_REPORT;
       break;
+    case mpsoc::TC_FLASH_GET_DIRECTORY_CONTENT: {
+      nextReplyId = mpsoc::TM_FLASH_DIRECTORY_CONTENT;
+      break;
+    }
+    case mpsoc::TC_GET_HK_REPORT: {
+      nextReplyId = mpsoc::TM_GET_HK_REPORT;
+      break;
+    }
     default:
       /* If no telemetry is expected the next reply is always the execution report */
       nextReplyId = mpsoc::EXE_REPORT;
       break;
   }
 }
+
 size_t PlocMPSoCHandler::getNextReplyLength(DeviceCommandId_t commandId) {
   size_t replyLen = 0;
 
@@ -881,6 +1222,10 @@ size_t PlocMPSoCHandler::getNextReplyLength(DeviceCommandId_t commandId) {
         // report is not fixed
         replyLen = mpsoc::SP_MAX_SIZE;
         break;
+      case mpsoc::TM_FLASH_DIRECTORY_CONTENT:
+        // I think the reply size is not fixed either.
+        replyLen = mpsoc::SP_MAX_SIZE;
+        break;
       default: {
         replyLen = iter->second.replyLen;
         break;
@@ -958,7 +1303,7 @@ void PlocMPSoCHandler::completionFailedReceived(ActionId_t actionId, ReturnValue
   handleActionCommandFailure(actionId);
 }
 
-void PlocMPSoCHandler::handleDeviceTM(const uint8_t* data, size_t dataSize,
+void PlocMPSoCHandler::handleDeviceTm(const uint8_t* data, size_t dataSize,
                                       DeviceCommandId_t replyId) {
   ReturnValue_t result = returnvalue::OK;
 
@@ -996,6 +1341,13 @@ void PlocMPSoCHandler::disableAllReplies() {
 
   DeviceCommandId_t commandId = getPendingCommand();
 
+  auto disableCommandWithReply = [&](DeviceCommandId_t replyId) {
+    iter = deviceReplyMap.find(replyId);
+    info = &(iter->second);
+    info->delayCycles = 0;
+    info->active = false;
+    info->command = deviceCommandMap.end();
+  };
   /* If the command expects a telemetry packet the appropriate tm reply will be disabled here */
   switch (commandId) {
     case TC_MEM_WRITE:
@@ -1013,19 +1365,19 @@ void PlocMPSoCHandler::disableAllReplies() {
     case TC_MODE_SNAPSHOT:
       break;
     case TC_MEM_READ: {
-      iter = deviceReplyMap.find(TM_MEMORY_READ_REPORT);
-      info = &(iter->second);
-      info->delayCycles = 0;
-      info->active = false;
-      info->command = deviceCommandMap.end();
+      disableCommandWithReply(TM_MEMORY_READ_REPORT);
+      break;
+    }
+    case TC_GET_HK_REPORT: {
+      disableCommandWithReply(TM_GET_HK_REPORT);
+      break;
+    }
+    case TC_FLASH_GET_DIRECTORY_CONTENT: {
+      disableCommandWithReply(TM_FLASH_DIRECTORY_CONTENT);
       break;
     }
     case TC_CAM_CMD_SEND: {
-      iter = deviceReplyMap.find(TM_CAM_CMD_RPT);
-      info = &(iter->second);
-      info->delayCycles = 0;
-      info->active = false;
-      info->command = deviceCommandMap.end();
+      disableCommandWithReply(TM_CAM_CMD_RPT);
       break;
     }
     default: {
@@ -1067,12 +1419,12 @@ void PlocMPSoCHandler::disableExeReportReply() {
 }
 
 void PlocMPSoCHandler::printStatus(const uint8_t* data) {
-  uint16_t status = *(data + STATUS_OFFSET) << 8 | *(data + STATUS_OFFSET + 1);
+  uint16_t status = (*(data + STATUS_OFFSET) << 8) | *(data + STATUS_OFFSET + 1);
   sif::info << "Verification report status: " << getStatusString(status) << std::endl;
 }
 
 uint16_t PlocMPSoCHandler::getStatus(const uint8_t* data) {
-  return *(data + STATUS_OFFSET) << 8 | *(data + STATUS_OFFSET + 1);
+  return (*(data + STATUS_OFFSET) << 8) | *(data + STATUS_OFFSET + 1);
 }
 
 void PlocMPSoCHandler::handleActionCommandFailure(ActionId_t actionId) {
@@ -1108,6 +1460,13 @@ void PlocMPSoCHandler::handleActionCommandFailure(ActionId_t actionId) {
   return;
 }
 
+LocalPoolDataSetBase* PlocMPSoCHandler::getDataSetHandle(sid_t sid) {
+  if (sid == hkReport.getSid()) {
+    return &hkReport;
+  }
+  return nullptr;
+}
+
 std::string PlocMPSoCHandler::getStatusString(uint16_t status) {
   switch (status) {
     case (mpsoc::status_code::UNKNOWN_APID): {
diff --git a/linux/payload/PlocMpsocHandler.h b/linux/payload/PlocMpsocHandler.h
index 10e6bd5d..a6af8156 100644
--- a/linux/payload/PlocMpsocHandler.h
+++ b/linux/payload/PlocMpsocHandler.h
@@ -77,7 +77,8 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
                                       uint8_t expectedReplies = 1, bool useAlternateId = false,
                                       DeviceCommandId_t alternateReplyID = 0) override;
   size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
-  virtual ReturnValue_t doSendReadHook() override;
+  ReturnValue_t doSendReadHook() override;
+  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 
  private:
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HANDLER;
@@ -105,6 +106,9 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
   static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
   static const uint8_t STATUS_OFFSET = 10;
 
+  mpsoc::HkReport hkReport;
+
+  bool normalCmdPending = false;
   MessageQueueIF* eventQueue = nullptr;
   MessageQueueIF* commandActionHelperQueue = nullptr;
 
@@ -114,6 +118,41 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
   SpacePacketCreator creator;
   ploc::SpTcParams spParams = ploc::SpTcParams(creator);
 
+  PoolEntry<uint32_t> peStatus = PoolEntry<uint32_t>();
+  PoolEntry<uint8_t> peMode = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkPwrOn = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkReplyActive = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkJesdSyncStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkDacStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peCameraStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peCameraSdiStatus = PoolEntry<uint8_t>();
+  PoolEntry<float> peCameraFpgaTemp = PoolEntry<float>();
+  PoolEntry<float> peCameraSocTemp = PoolEntry<float>();
+  PoolEntry<float> peSysmonTemp = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccInt = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccAux = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccBram = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccPaux = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccPint = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccPdro = PoolEntry<float>();
+  PoolEntry<float> peSysmonMb12V = PoolEntry<float>();
+  PoolEntry<float> peSysmonMb3V3 = PoolEntry<float>();
+  PoolEntry<float> peSysmonMb1V8 = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc12V = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc5V = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc3V3 = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc3V3VA = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc2V5DDR = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc1V2DDR = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc0V9 = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc0V6VTT = PoolEntry<float>();
+  PoolEntry<float> peSysmonSafeCotsCur = PoolEntry<float>();
+  PoolEntry<float> peSysmonNvm4XoCur = PoolEntry<float>();
+  PoolEntry<uint16_t> peSemUncorrectableErrs = PoolEntry<uint16_t>();
+  PoolEntry<uint16_t> peSemCorrectableErrs = PoolEntry<uint16_t>();
+  PoolEntry<uint8_t> peSemStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peRebootMpsocRequired = PoolEntry<uint8_t>();
+
   /**
    * This variable is used to store the id of the next reply to receive. This is necessary
    * because the PLOC sends as reply to each command at least one acknowledgment and execution
@@ -130,6 +169,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
 
   // Used to block incoming commands when MPSoC helper class is currently executing a command
   bool plocMPSoCHelperExecuting = false;
+  bool commandIsPending = false;
 
   struct TmMemReadReport {
     static const uint8_t FIX_SIZE = 14;
@@ -138,19 +178,16 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
 
   TmMemReadReport tmMemReadReport;
 
-  struct TmCamCmdRpt {
-    size_t rememberSpacePacketSize = 0;
-  };
-
-  TmCamCmdRpt tmCamCmdRpt;
-
   struct TelemetryBuffer {
     uint16_t length = 0;
     uint8_t buffer[mpsoc::SP_MAX_SIZE];
   };
 
+  size_t foundPacketLen = 0;
   TelemetryBuffer tmBuffer;
+  uint32_t waitCycles = 0;
 
+  enum class StartupState { IDLE, HW_INIT, WAIT_CYCLES, DONE } startupState = StartupState::IDLE;
   enum class PowerState { OFF, BOOTING, SHUTDOWN, ON };
 
   PowerState powerState = PowerState::OFF;
@@ -167,6 +204,8 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
   ReturnValue_t prepareTcReplayStop();
   ReturnValue_t prepareTcDownlinkPwrOn(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcDownlinkPwrOff();
+  ReturnValue_t prepareTcGetHkReport();
+  ReturnValue_t prepareTcGetDirContent(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcCamCmdSend(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcModeIdle();
@@ -213,6 +252,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
    */
   ReturnValue_t handleMemoryReadReport(const uint8_t* data);
 
+  ReturnValue_t handleGetHkReport(const uint8_t* data);
   ReturnValue_t handleCamCmdRpt(const uint8_t* data);
 
   /**
@@ -231,7 +271,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
    * @param dataSize  Size of telemetry in bytes.
    * @param replyId   Id of the reply. This will be added to the ActionMessage.
    */
-  void handleDeviceTM(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId);
+  void handleDeviceTm(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId);
 
   /**
    * @brief   In case an acknowledgment failure reply has been received this function disables
diff --git a/linux/payload/plocMpscoDefs.h b/linux/payload/plocMpscoDefs.h
index 975dad32..c5d53e6f 100644
--- a/linux/payload/plocMpscoDefs.h
+++ b/linux/payload/plocMpscoDefs.h
@@ -1,6 +1,7 @@
 #ifndef MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
 #define MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
 
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
 #include <linux/payload/mpsocRetvals.h>
 #include <mission/payload/plocSpBase.h>
@@ -12,6 +13,47 @@
 
 namespace mpsoc {
 
+static constexpr uint32_t HK_SET_ID = 0;
+
+namespace poolid {
+enum {
+  STATUS = 0,
+  MODE = 1,
+  DOWNLINK_PWR_ON = 2,
+  DOWNLINK_REPLY_ACTIIVE = 3,
+  DOWNLINK_JESD_SYNC_STATUS = 4,
+  DOWNLINK_DAC_STATUS = 5,
+  CAM_STATUS = 6,
+  CAM_SDI_STATUS = 7,
+  CAM_FPGA_TEMP = 8,
+  CAM_SOC_TEMP = 9,
+  SYSMON_TEMP = 10,
+  SYSMON_VCCINT = 11,
+  SYSMON_VCCAUX = 12,
+  SYSMON_VCCBRAM = 13,
+  SYSMON_VCCPAUX = 14,
+  SYSMON_VCCPINT = 15,
+  SYSMON_VCCPDRO = 16,
+  SYSMON_MB12V = 17,
+  SYSMON_MB3V3 = 18,
+  SYSMON_MB1V8 = 19,
+  SYSMON_VCC12V = 20,
+  SYSMON_VCC5V = 21,
+  SYSMON_VCC3V3 = 22,
+  SYSMON_VCC3V3VA = 23,
+  SYSMON_VCC2V5DDR = 24,
+  SYSMON_VCC1V2DDR = 25,
+  SYSMON_VCC0V9 = 26,
+  SYSMON_VCC0V6VTT = 27,
+  SYSMON_SAFE_COTS_CUR = 28,
+  SYSMON_NVM4_XO_CUR = 29,
+  SEM_UNCORRECTABLE_ERRS = 30,
+  SEM_CORRECTABLE_ERRS = 31,
+  SEM_STATUS = 32,
+  REBOOT_MPSOC_REQUIRED = 33,
+};
+}
+
 static const DeviceCommandId_t NONE = 0;
 static const DeviceCommandId_t TC_MEM_WRITE = 1;
 static const DeviceCommandId_t TC_MEM_READ = 2;
@@ -37,6 +79,10 @@ static const DeviceCommandId_t TC_CAM_TAKE_PIC = 22;
 static const DeviceCommandId_t TC_SIMPLEX_SEND_FILE = 23;
 static const DeviceCommandId_t TC_DOWNLINK_DATA_MODULATE = 24;
 static const DeviceCommandId_t TC_MODE_SNAPSHOT = 25;
+static const DeviceCommandId_t TC_GET_HK_REPORT = 26;
+static const DeviceCommandId_t TM_GET_HK_REPORT = 27;
+static const DeviceCommandId_t TC_FLASH_GET_DIRECTORY_CONTENT = 28;
+static const DeviceCommandId_t TM_FLASH_DIRECTORY_CONTENT = 29;
 
 // Will reset the sequence count of the OBSW
 static const DeviceCommandId_t OBSW_RESET_SEQ_COUNT = 50;
@@ -45,6 +91,7 @@ static const uint16_t SIZE_ACK_REPORT = 14;
 static const uint16_t SIZE_EXE_REPORT = 14;
 static const uint16_t SIZE_TM_MEM_READ_REPORT = 18;
 static const uint16_t SIZE_TM_CAM_CMD_RPT = 18;
+static constexpr size_t SIZE_TM_HK_REPORT = 369;
 
 /**
  * SpacePacket apids of PLOC telecommands and telemetry.
@@ -60,20 +107,27 @@ static const uint16_t TC_CAM_TAKE_PIC = 0x116;
 static const uint16_t TC_FLASHWRITE = 0x117;
 static const uint16_t TC_FLASHFOPEN = 0x119;
 static const uint16_t TC_FLASHFCLOSE = 0x11A;
+static constexpr uint16_t TC_FLASH_GET_DIRECTORY_CONTENT = 0x11B;
 static const uint16_t TC_FLASHDELETE = 0x11C;
+static constexpr uint16_t TC_FLASH_CREATE_DIR = 0x11D;
 static const uint16_t TC_MODE_IDLE = 0x11E;
 static const uint16_t TC_MODE_REPLAY = 0x11F;
 static const uint16_t TC_MODE_SNAPSHOT = 0x120;
 static const uint16_t TC_DOWNLINK_DATA_MODULATE = 0x121;
+static constexpr uint16_t TC_HK_GET_REPORT = 0x123;
 static const uint16_t TC_DOWNLINK_PWR_OFF = 0x124;
 static const uint16_t TC_CAM_CMD_SEND = 0x12C;
+static constexpr uint16_t TC_FLASH_COPY_FILE = 0x12E;
 static const uint16_t TC_SIMPLEX_SEND_FILE = 0x130;
-static const uint16_t TM_MEMORY_READ_REPORT = 0x404;
+
 static const uint16_t ACK_SUCCESS = 0x400;
 static const uint16_t ACK_FAILURE = 0x401;
 static const uint16_t EXE_SUCCESS = 0x402;
 static const uint16_t EXE_FAILURE = 0x403;
+static const uint16_t TM_MEMORY_READ_REPORT = 0x404;
+static constexpr uint16_t TM_FLASH_DIRECTORY_CONTENT = 0x406;
 static const uint16_t TM_CAM_CMD_RPT = 0x407;
+static constexpr uint16_t TM_HK_GET_REPORT = 0x408;
 }  // namespace apid
 
 /** Offset from first byte in space packet to first byte of data field */
@@ -561,6 +615,30 @@ class TcDownlinkPwrOn : public TcBase {
   }
 };
 
+class TcGetHkReport : public TcBase {
+ public:
+  TcGetHkReport(ploc::SpTcParams params, uint16_t sequenceCount)
+      : TcBase(params, apid::TC_HK_GET_REPORT, sequenceCount) {}
+};
+
+class TcGetDirContent : public TcBase {
+ public:
+  TcGetDirContent(ploc::SpTcParams params, uint16_t sequenceCount)
+      : TcBase(params, apid::TC_FLASH_GET_DIRECTORY_CONTENT, sequenceCount) {}
+
+  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
+    ReturnValue_t result = returnvalue::OK;
+    // Yeah it needs to be 256.. even if the path is shorter.
+    spParams.setFullPayloadLen(256 + CRC_SIZE);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    std::memcpy(payloadStart, commandData, commandDataLen);
+    payloadStart[255] = '\0';
+    return result;
+  }
+};
+
 /**
  * @brief   Class to build replay stop space packet.
  */
@@ -774,6 +852,66 @@ class TcCamcmdSend : public TcBase {
   static const uint8_t CARRIAGE_RETURN = 0xD;
 };
 
+class HkReport : public StaticLocalDataSet<36> {
+ public:
+  HkReport(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, HK_SET_ID) {}
+
+  HkReport(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, HK_SET_ID)) {}
+
+  lp_var_t<uint32_t> status = lp_var_t<uint32_t>(sid.objectId, mpsoc::poolid::STATUS, this);
+  lp_var_t<uint8_t> mode = lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::MODE, this);
+  lp_var_t<uint8_t> downlinkPwrOn =
+      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::DOWNLINK_PWR_ON, this);
+  lp_var_t<uint8_t> downlinkReplyActive =
+      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::DOWNLINK_REPLY_ACTIIVE, this);
+  lp_var_t<uint8_t> downlinkJesdSyncStatus =
+      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::DOWNLINK_JESD_SYNC_STATUS, this);
+  lp_var_t<uint8_t> downlinkDacStatus =
+      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::DOWNLINK_DAC_STATUS, this);
+  lp_var_t<uint8_t> camStatus = lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::CAM_STATUS, this);
+  lp_var_t<uint8_t> camSdiStatus =
+      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::CAM_SDI_STATUS, this);
+  lp_var_t<float> camFpgaTemp = lp_var_t<float>(sid.objectId, mpsoc::poolid::CAM_FPGA_TEMP, this);
+  lp_var_t<float> camSocTemp = lp_var_t<float>(sid.objectId, mpsoc::poolid::CAM_SOC_TEMP, this);
+  lp_var_t<float> sysmonTemp = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_TEMP, this);
+  lp_var_t<float> sysmonVccInt = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCINT, this);
+  lp_var_t<float> sysmonVccAux = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCAUX, this);
+  lp_var_t<float> sysmonVccBram =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCBRAM, this);
+  lp_var_t<float> sysmonVccPaux =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCPAUX, this);
+  lp_var_t<float> sysmonVccPint =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCPINT, this);
+  lp_var_t<float> sysmonVccPdro =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCCPDRO, this);
+  lp_var_t<float> sysmonMb12V = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_MB12V, this);
+  lp_var_t<float> sysmonMb3V3 = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_MB3V3, this);
+  lp_var_t<float> sysmonMb1V8 = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_MB1V8, this);
+  lp_var_t<float> sysmonVcc12V = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC12V, this);
+  lp_var_t<float> sysmonVcc5V = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC5V, this);
+  lp_var_t<float> sysmonVcc3V3 = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC3V3, this);
+  lp_var_t<float> sysmonVcc3V3VA =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC3V3VA, this);
+  lp_var_t<float> sysmonVcc2V5DDR =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC2V5DDR, this);
+  lp_var_t<float> sysmonVcc1V2DDR =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC1V2DDR, this);
+  lp_var_t<float> sysmonVcc0V9 = lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC0V9, this);
+  lp_var_t<float> sysmonVcc0V6VTT =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_VCC0V6VTT, this);
+  lp_var_t<float> sysmonSafeCotsCur =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_SAFE_COTS_CUR, this);
+  lp_var_t<float> sysmonNvm4XoCur =
+      lp_var_t<float>(sid.objectId, mpsoc::poolid::SYSMON_NVM4_XO_CUR, this);
+  lp_var_t<uint16_t> semUncorrectableErrs =
+      lp_var_t<uint16_t>(sid.objectId, mpsoc::poolid::SEM_UNCORRECTABLE_ERRS, this);
+  lp_var_t<uint16_t> semCorrectableErrs =
+      lp_var_t<uint16_t>(sid.objectId, mpsoc::poolid::SEM_CORRECTABLE_ERRS, this);
+  lp_var_t<uint8_t> semStatus = lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::SEM_STATUS, this);
+  lp_var_t<uint8_t> rebootMpsocRequired =
+      lp_var_t<uint8_t>(sid.objectId, mpsoc::poolid::REBOOT_MPSOC_REQUIRED, this);
+};
+
 }  // namespace mpsoc
 
 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ */
diff --git a/mission/tcs/Tmp1075Definitions.h b/mission/tcs/Tmp1075Definitions.h
index 946ac82e..345146e6 100644
--- a/mission/tcs/Tmp1075Definitions.h
+++ b/mission/tcs/Tmp1075Definitions.h
@@ -29,7 +29,7 @@ static const uint8_t MAX_REPLY_LENGTH = GET_TEMP_REPLY_SIZE;
 
 enum Tmp1075PoolIds : lp_id_t { TEMPERATURE_C_TMP1075 };
 
-class Tmp1075Dataset : public StaticLocalDataSet<sizeof(float)> {
+class Tmp1075Dataset : public StaticLocalDataSet<2> {
  public:
   Tmp1075Dataset(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TMP1075_DATA_SET_ID) {}
 
diff --git a/tmtc b/tmtc
index f090c3af..0c1bfc6f 160000
--- a/tmtc
+++ b/tmtc
@@ -1 +1 @@
-Subproject commit f090c3af66d1a0b760344e80053d6e83895e661a
+Subproject commit 0c1bfc6fd32e66fe0da13bebc4eeb3030ead13a9