CHANGELOG.md

@@ -16,12 +16,48 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
+# [v2.2.0] to be released
+
+# [v2.1.0] to be released
+
+## Changed
+
+- Adapt EM configuration to include all GomSpace PCDU devices except the ACU. For the ACU
+  (which broke), a dummy will still be used.
+- Event Manager queue depth is configurable now.
+- Do not construct and schedule broken TMP1075 device anymore.
+- Do not track payload modes in system mode tables.
+- ACS modes derived from system modes.
+
+
+## Added
+
+- Add the remaining system modes.
+- 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.
+- PLOC MPSoC device handler: Read file support.
+
+## Fixed
+
+- Host build is working again. Added reduced live TM helper which schedules the PUS and CFDP
+  funnel.
+
+# [v2.0.5] to be released
+
+- The dual lane assembly transition failed handler started new transitions towards the current mode
+  instead of the target mode. This means that if the dual lane assembly never reached the initial
+  submode (e.g. mode normal and submode dual side), it will transition back to the current mode,
+  which miht be `MODE_OFF`. Furthermore, this can lead to invalid internal states, so the subsequent
+  recovery handling becomes stuck in the custom recovery sequence when swichting power back on.
+- The dual lane custom recovery handling was adapted to always perform proper power switch handling
+  irrespective of current or target modes.
+
 # [v2.0.4] 2023-04-19
 
 ## Fixed
 
-- The dual lane assembly device handlers did not properly set their datasets
+- The dual lane assembly datasets were not marked invalid properly on OFF transitions.
-  to invalid on off transitions
 
 # [v2.0.3] 2023-04-17
 

CMakeLists.txt

@@ -146,8 +146,11 @@ set(OBSW_ADD_TMP_DEVICES
     ${INIT_VAL}
     CACHE STRING "Add TMP devices")
 set(OBSW_ADD_GOMSPACE_PCDU
-    ${INIT_VAL}
+    1
     CACHE STRING "Add GomSpace PCDU modules")
+set(OBSW_ADD_GOMSPACE_ACU
+    ${INIT_VAL}
+    CACHE STRING "Add GomSpace ACU submodule")
 set(OBSW_ADD_RW
     ${INIT_VAL}
     CACHE STRING "Add RW modules")

bsp_hosted/ObjectFactory.cpp

@@ -64,8 +64,9 @@ void ObjectFactory::produce(void* args) {
   PersistentTmStores persistentStores;
   auto sdcMan = new DummySdCardManager("/tmp");
   ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel, *sdcMan, &ipcStore,
-                                       &tmStore, persistentStores);
+                                       &tmStore, persistentStores, 120);
 
+  new TmFunnelHandler(objects::LIVE_TM_TASK, *pusFunnel, *cfdpFunnel);
   auto* dummyGpioIF = new DummyGpioIF();
   auto* dummySwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
   std::vector<ReturnValue_t> switcherList;

bsp_hosted/scheduling.cpp

@@ -59,19 +59,15 @@ void scheduling::initTasks() {
       "DIST", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   ReturnValue_t result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
   if (result != returnvalue::OK) {
-    sif::error << "adding CCSDS distributor failed" << std::endl;
+    sif::error << "Adding CCSDS distributor failed" << std::endl;
   }
   result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
   if (result != returnvalue::OK) {
-    sif::error << "adding PUS distributor failed" << std::endl;
+    sif::error << "Adding PUS distributor failed" << std::endl;
-  }
-  result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
-  if (result != returnvalue::OK) {
-    sif::error << "adding TM funnel failed" << std::endl;
   }
   result = tmtcDistributor->addComponent(objects::CFDP_DISTRIBUTOR);
   if (result != returnvalue::OK) {
-    sif::error << "adding CFDP distributor failed" << std::endl;
+    sif::error << "Adding CFDP distributor failed" << std::endl;
   }
   result = tmtcDistributor->addComponent(objects::UDP_TMTC_SERVER);
   if (result != returnvalue::OK) {
@@ -95,6 +91,13 @@ void scheduling::initTasks() {
     sif::error << "Add component UDP Polling failed" << std::endl;
   }
 
+  PeriodicTaskIF* liveTmTask = factory->createPeriodicTask(
+      "LIVE_TM", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, nullptr, &RR_SCHEDULING);
+  result = liveTmTask->addComponent(objects::LIVE_TM_TASK);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("LIVE_TM", objects::LIVE_TM_TASK);
+  }
+
   PeriodicTaskIF* pusHighPrio = factory->createPeriodicTask(
       "PUS_HIGH_PRIO", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
   result = pusHighPrio->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
@@ -149,7 +152,7 @@ void scheduling::initTasks() {
       "THERMAL_CTL_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
   result = thermalTask->addComponent(objects::CORE_CONTROLLER);
   if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("Core controller dummy", objects::CORE_CONTROLLER);
+    scheduling::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
   }
   result = thermalTask->addComponent(objects::THERMAL_CONTROLLER);
   if (result != returnvalue::OK) {
@@ -217,6 +220,7 @@ void scheduling::initTasks() {
   tmtcDistributor->startTask();
   udpPollingTask->startTask();
   tcpPollingTask->startTask();
+  liveTmTask->startTask();
 
   pusHighPrio->startTask();
   pusMedPrio->startTask();

bsp_q7s/OBSWConfig.h.in

@@ -22,6 +22,9 @@
 #define OBSW_COMMAND_SAFE_MODE_AT_STARTUP           1
 
 #define OBSW_ADD_GOMSPACE_PCDU                      @OBSW_ADD_GOMSPACE_PCDU@
+// This define is necessary because the EM setup has the P60 dock module, but no ACU on the P60
+// module because it broke.
+#define OBSW_ADD_GOMSPACE_ACU                       @OBSW_ADD_GOMSPACE_ACU@
 #define OBSW_ADD_MGT                                @OBSW_ADD_MGT@
 #define OBSW_ADD_BPX_BATTERY_HANDLER                @OBSW_ADD_BPX_BATTERY_HANDLER@
 #define OBSW_ADD_STAR_TRACKER                       @OBSW_ADD_STAR_TRACKER@

bsp_q7s/core/ObjectFactory.cpp

@@ -189,7 +189,6 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF,
   *i2cComIF = new I2cComIF(objects::I2C_COM_IF);
   *uartComIF = new SerialComIF(objects::UART_COM_IF);
   *spiMainComIF = new SpiComIF(objects::SPI_MAIN_COM_IF, q7s::SPI_DEFAULT_DEV, **gpioComIF);
-  //*spiRWComIF = new SpiComIF(objects::SPI_RW_COM_IF, q7s::SPI_RW_DEV, **gpioComIF);
 }
 
 void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher,
@@ -197,7 +196,6 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI
   CspCookie* p60DockCspCookie = new CspCookie(P60Dock::MAX_REPLY_SIZE, addresses::P60DOCK, 500);
   CspCookie* pdu1CspCookie = new CspCookie(PDU::MAX_REPLY_SIZE, addresses::PDU1, 500);
   CspCookie* pdu2CspCookie = new CspCookie(PDU::MAX_REPLY_SIZE, addresses::PDU2, 500);
-  CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_SIZE, addresses::ACU, 500);
 
   auto p60Fdir = new GomspacePowerFdir(objects::P60DOCK_HANDLER);
   P60DockHandler* p60dockhandler = new P60DockHandler(objects::P60DOCK_HANDLER, objects::CSP_COM_IF,
@@ -211,9 +209,12 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI
   Pdu2Handler* pdu2handler = new Pdu2Handler(objects::PDU2_HANDLER, objects::CSP_COM_IF,
                                              pdu2CspCookie, pdu2Fdir, enableHkSets);
 
+#if OBSW_ADD_GOMSPACE_ACU == 1
+  CspCookie* acuCspCookie = new CspCookie(ACU::MAX_REPLY_SIZE, addresses::ACU, 500);
   auto acuFdir = new GomspacePowerFdir(objects::ACU_HANDLER);
   ACUHandler* acuhandler = new ACUHandler(objects::ACU_HANDLER, objects::CSP_COM_IF, acuCspCookie,
                                           acuFdir, enableHkSets);
+#endif
   auto pcduHandler = new PcduHandler(objects::PCDU_HANDLER, 50);
 
   /**
@@ -223,7 +224,9 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI
   p60dockhandler->setModeNormal();
   pdu1handler->setModeNormal();
   pdu2handler->setModeNormal();
+#if OBSW_ADD_GOMSPACE_ACU == 1
   acuhandler->setModeNormal();
+#endif
   if (pwrSwitcher != nullptr) {
     *pwrSwitcher = pcduHandler;
   }

bsp_q7s/em/emObjectFactory.cpp

@@ -36,7 +36,8 @@ void ObjectFactory::produce(void* args) {
 
   PersistentTmStores stores;
   ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
-                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores);
+                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores,
+                                       200);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
   SerialComIF* uartComIF = nullptr;
@@ -56,6 +57,11 @@ void ObjectFactory::produce(void* args) {
 #endif
 #if OBSW_ADD_GOMSPACE_PCDU == 1
   dummyCfg.addPowerDummies = false;
+  // The ACU broke.
+  dummyCfg.addOnlyAcuDummy = true;
+#endif
+#if OBSW_ADD_BPX_BATTERY_HANDLER == 1
+  dummyCfg.addBpxBattDummy = false;
 #endif
 #if OBSW_ADD_ACS_BOARD == 1
   dummyCfg.addAcsBoardDummies = false;
@@ -89,7 +95,7 @@ void ObjectFactory::produce(void* args) {
   // createRadSensorComponent(gpioComIF);
 
 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher);
+  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher, true);
 #else
   // Still add all GPIOs for EM.
   GpioCookie* acsBoardGpios = new GpioCookie();

bsp_q7s/fmObjectFactory.cpp

@@ -32,7 +32,8 @@ void ObjectFactory::produce(void* args) {
 
   PersistentTmStores stores;
   ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
-                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores);
+                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores,
+                                       200);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
   SerialComIF* uartComIF = nullptr;

dummies/helperFactory.cpp

@@ -45,7 +45,9 @@
 void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpioIF) {
   new ComIFDummy(objects::DUMMY_COM_IF);
   auto* comCookieDummy = new ComCookieDummy();
+  if (cfg.addBpxBattDummy) {
     new BpxDummy(objects::BPX_BATT_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  }
   if (cfg.addCoreCtrlCfg) {
     new CoreControllerDummy(objects::CORE_CONTROLLER);
   }
@@ -75,8 +77,9 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
   auto* imtqDummy = new ImtqDummy(objects::IMTQ_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
   imtqDummy->enableThermalModule(ThermalStateCfg());
   imtqDummy->connectModeTreeParent(*imtqAssy);
-  if (cfg.addPowerDummies) {
+  if (cfg.addOnlyAcuDummy) {
     new AcuDummy(objects::ACU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  } else if (cfg.addPowerDummies) {
     new PduDummy(objects::PDU1_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
     new PduDummy(objects::PDU2_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
     new P60DockDummy(objects::P60DOCK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);

dummies/helperFactory.h

@@ -6,9 +6,13 @@ class GpioIF;
 
 namespace dummy {
 
+// Default values targeted towards EM.
 struct DummyCfg {
   bool addCoreCtrlCfg = true;
+  // Special variant because the ACU broke. Overrides addPowerDummies, only ACU dummy will be added.
+  bool addOnlyAcuDummy = false;
   bool addPowerDummies = true;
+  bool addBpxBattDummy = true;
   bool addSyrlinksDummies = true;
   bool addAcsBoardDummies = true;
   bool addSusDummies = true;

linux/payload/PlocMpsocHandler.cpp

@@ -11,6 +11,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),
@@ -159,6 +160,7 @@ void PlocMPSoCHandler::doStartUp() {
       powerState = PowerState::BOOTING;
       break;
     case PowerState::ON:
+      hkReport.setReportingEnabled(true);
       setMode(_MODE_TO_ON);
       uartIsolatorSwitch.pullHigh();
       break;
@@ -167,11 +169,13 @@ void PlocMPSoCHandler::doStartUp() {
   }
 #else
   powerState = PowerState::ON;
+  hkReport.setReportingEnabled(true);
   setMode(_MODE_TO_ON);
   uartIsolatorSwitch.pullHigh();
 #endif /* not MSPOC_JTAG_BOOT == 1 */
 #else
   powerState = PowerState::ON;
+  hkReport.setReportingEnabled(true);
   setMode(_MODE_TO_ON);
 #endif /* XIPHOS_Q7S */
 }
@@ -187,6 +191,7 @@ void PlocMPSoCHandler::doShutDown() {
       break;
     case PowerState::OFF:
       sequenceCount = 0;
+      hkReport.setReportingEnabled(false);
       setMode(_MODE_POWER_DOWN);
       break;
     default:
@@ -195,6 +200,7 @@ void PlocMPSoCHandler::doShutDown() {
 #else
   sequenceCount = 0;
   uartIsolatorSwitch.pullLow();
+  hkReport.setReportingEnabled(false);
   setMode(_MODE_POWER_DOWN);
   powerState = PowerState::OFF;
 #endif
@@ -202,7 +208,8 @@ void PlocMPSoCHandler::doShutDown() {
 }
 
 ReturnValue_t PlocMPSoCHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
-  return NOTHING_TO_SEND;
+  *id = mpsoc::TC_GET_HK_REPORT;
+  return buildCommandFromCommand(*id, nullptr, 0);
 }
 
 ReturnValue_t PlocMPSoCHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
@@ -247,6 +254,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 +319,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, 2, 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, 0);
 }
 
 ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remainingSize,
@@ -331,6 +350,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 +369,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();
+      handleDedicatedReply(mpsoc::TM_CAM_CMD_RPT);
-      tmCamCmdRpt.rememberSpacePacketSize = *foundLen;
-      *foundId = 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;
@@ -386,10 +416,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 +449,49 @@ 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; }
 
 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_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_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 +595,17 @@ ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOff() {
   return returnvalue::OK;
 }
 
+ReturnValue_t PlocMPSoCHandler::prepareTcGetHkReport() {
+  ReturnValue_t result = returnvalue::OK;
+  mpsoc::TcGetHkReport tcDownlinkPwrOff(spParams, sequenceCount);
+  result = tcDownlinkPwrOff.buildPacket();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  finishTcPrep(tcDownlinkPwrOff.getFullPacketLen());
+  return returnvalue::OK;
+}
+
 ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* commandData,
                                                              size_t commandDataLen) {
   ReturnValue_t result = returnvalue::OK;
@@ -561,9 +655,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 +666,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 +675,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 +698,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;
   }
@@ -718,30 +819,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;
+  ReturnValue_t result = verifyPacket(data, foundPacketLen);
-  result = verifyPacket(data, tmCamCmdRpt.rememberSpacePacketSize);
   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(
+  std::string camCmdRptMsg(reinterpret_cast<const char*>(dataFieldPtr),
-      reinterpret_cast<const char*>(dataFieldPtr),
+                           foundPacketLen - mpsoc::SPACE_PACKET_HEADER_SIZE - sizeof(uint16_t) - 3);
-      tmCamCmdRpt.rememberSpacePacketSize - 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 +1030,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 +1056,30 @@ ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator
     case mpsoc::TC_MODE_SNAPSHOT:
       enabledReplies = 2;
       break;
-    case mpsoc::TC_MEM_READ: {
+    case mpsoc::TC_GET_HK_REPORT: {
-      enabledReplies = 3;
+      result = enableThreeReplies(mpsoc::TM_GET_HK_REPORT);
-      result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
+      if (result != returnvalue::OK) {
-                                                        mpsoc::TM_MEMORY_READ_REPORT);
+        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 = enableThreeReplies(mpsoc::TM_CAM_CMD_RPT);
-      result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
+      if (result != returnvalue::OK) {
-                                                        mpsoc::TM_CAM_CMD_RPT);
+        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;
@@ -857,6 +1150,7 @@ void PlocMPSoCHandler::setNextReplyId() {
       break;
   }
 }
+
 size_t PlocMPSoCHandler::getNextReplyLength(DeviceCommandId_t commandId) {
   size_t replyLen = 0;
 
@@ -881,6 +1175,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 +1256,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 +1294,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 +1318,19 @@ void PlocMPSoCHandler::disableAllReplies() {
     case TC_MODE_SNAPSHOT:
       break;
     case TC_MEM_READ: {
-      iter = deviceReplyMap.find(TM_MEMORY_READ_REPORT);
+      disableCommandWithReply(TM_MEMORY_READ_REPORT);
-      info = &(iter->second);
+      break;
-      info->delayCycles = 0;
+    }
-      info->active = false;
+    case TC_GET_HK_REPORT: {
-      info->command = deviceCommandMap.end();
+      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);
+      disableCommandWithReply(TM_CAM_CMD_RPT);
-      info = &(iter->second);
-      info->delayCycles = 0;
-      info->active = false;
-      info->command = deviceCommandMap.end();
       break;
     }
     default: {
@@ -1108,6 +1413,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): {

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,8 @@ 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;
+
   MessageQueueIF* eventQueue = nullptr;
   MessageQueueIF* commandActionHelperQueue = nullptr;
 
@@ -114,6 +117,41 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
   SpacePacketCreator creator;
   ploc::SpTcParams spParams = ploc::SpTcParams(creator);
 
+  PoolEntry<uint8_t> peStatus = PoolEntry<uint8_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
@@ -138,17 +176,12 @@ 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;
 
   enum class PowerState { OFF, BOOTING, SHUTDOWN, ON };
@@ -167,6 +200,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 +248,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 +267,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

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,19 +107,25 @@ 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 constexpr uint16_t TM_HK_GET_REPORT = 0x408;
 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 constexpr uint16_t TM_FLASH_DIRECTORY_CONTENT = 0x406;
 static const uint16_t TM_CAM_CMD_RPT = 0x407;
 }  // namespace apid
 
@@ -561,6 +614,32 @@ class TcDownlinkPwrOn : public TcBase {
   }
 };
 
+/**
+ * @brief   Class to build replay stop space packet.
+ */
+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;
+    spParams.setFullPayloadLen(commandDataLen + sizeof(NULL_TERMINATOR) + CRC_SIZE);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    std::memcpy(payloadStart, commandData, commandDataLen);
+    *(payloadStart + commandDataLen) = NULL_TERMINATOR;
+    return result;
+  }
+};
+
 /**
  * @brief   Class to build replay stop space packet.
  */
@@ -774,6 +853,67 @@ 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_CORRECTABLE_ERRS, 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_ */

mission/acs/defs.h

@@ -3,6 +3,7 @@
 
 #include <eive/eventSubsystemIds.h>
 #include <fsfw/modes/HasModesIF.h>
+#include <mission/sysDefs.h>
 
 namespace acs {
 
@@ -11,12 +12,12 @@ enum class SimpleSensorMode { NORMAL = 0, OFF = 1 };
 // These modes are the modes of the ACS controller and of the ACS subsystem.
 enum AcsMode : Mode_t {
   OFF = HasModesIF::MODE_OFF,
-  SAFE = 10,
+  SAFE = satsystem::Mode::SAFE,
-  PTG_IDLE = 11,
+  PTG_IDLE = satsystem::Mode::PTG_IDLE,
-  PTG_NADIR = 12,
+  PTG_NADIR = satsystem::Mode::PTG_NADIR,
-  PTG_TARGET = 13,
+  PTG_TARGET = satsystem::Mode::PTG_TARGET,
-  PTG_TARGET_GS = 14,
+  PTG_TARGET_GS = satsystem::Mode::PTG_TARGET_GS,
-  PTG_INERTIAL = 15,
+  PTG_INERTIAL = satsystem::Mode::PTG_INERTIAL,
 };
 
 enum SafeSubmode : Submode_t { DEFAULT = 0, DETUMBLE = 1 };

mission/genericFactory.cpp

@@ -96,9 +96,10 @@ std::atomic_bool tcs::TCS_BOARD_SHORTLY_UNAVAILABLE = false;
 void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFunnel** pusFunnel,
                                           CfdpTmFunnel** cfdpFunnel, SdCardMountedIF& sdcMan,
                                           StorageManagerIF** ipcStore, StorageManagerIF** tmStore,
-                                          PersistentTmStores& stores) {
+                                          PersistentTmStores& stores,
+                                          uint32_t eventManagerQueueDepth) {
   // Framework objects
-  new EventManager(objects::EVENT_MANAGER, 160);
+  new EventManager(objects::EVENT_MANAGER, eventManagerQueueDepth);
   auto healthTable = new HealthTable(objects::HEALTH_TABLE);
   if (healthTable_ != nullptr) {
     *healthTable_ = healthTable;

mission/genericFactory.h

@@ -45,7 +45,7 @@ namespace ObjectFactory {
 void produceGenericObjects(HealthTableIF** healthTable, PusTmFunnel** pusFunnel,
                            CfdpTmFunnel** cfdpFunnel, SdCardMountedIF& sdcMan,
                            StorageManagerIF** ipcStore, StorageManagerIF** tmStore,
-                           PersistentTmStores& stores);
+                           PersistentTmStores& stores, uint32_t eventManagerQueueDepth);
 void createGenericHeaterComponents(GpioIF& gpioIF, PowerSwitchIF& pwrSwitcher,
                                    HeaterHandler*& heaterHandler);
 

mission/scheduling.cpp

@@ -5,9 +5,11 @@
 #include "fsfw/tasks/PeriodicTaskIF.h"
 
 void scheduling::scheduleTmpTempSensors(PeriodicTaskIF* tmpTask) {
-  const std::array<object_id_t, 5> tmpIds = {
+  const std::array<object_id_t, 4> tmpIds = {objects::TMP1075_HANDLER_TCS_0,
-      objects::TMP1075_HANDLER_TCS_0, objects::TMP1075_HANDLER_TCS_1,
+                                             objects::TMP1075_HANDLER_TCS_1,
-      objects::TMP1075_HANDLER_PLPCDU_0, objects::TMP1075_HANDLER_PLPCDU_1,
+                                             objects::TMP1075_HANDLER_PLPCDU_0,
+                                             // damaged.
+                                             // objects::TMP1075_HANDLER_PLPCDU_1,
                                              objects::TMP1075_HANDLER_IF_BOARD};
   for (const auto& tmpId : tmpIds) {
     tmpTask->addComponent(tmpId, DeviceHandlerIF::PERFORM_OPERATION);

mission/sysDefs.h

@@ -1,16 +1,28 @@
 #ifndef MISSION_SYSDEFS_H_
 #define MISSION_SYSDEFS_H_
 
-#include <atomic>
+#include <fsfw/action/ActionMessage.h>
+#include <fsfw/action/HasActionsIF.h>
+#include <fsfw/modes/ModeMessage.h>
+#include <fsfw/serialize/SerializeIF.h>
 
-#include "acs/defs.h"
+#include <atomic>
+#include <cstring>
 
 extern std::atomic_uint16_t I2C_FATAL_ERRORS;
 
 namespace satsystem {
 
-enum Mode : Mode_t { BOOT = 5, SAFE = acs::AcsMode::SAFE, PTG_IDLE = acs::AcsMode::PTG_IDLE };
+enum Mode : Mode_t {
-
+  BOOT = 5,
+  // DO NOT CHANGE THE ORDER starting from here, breaks ACS mode checks.
+  SAFE = 10,
+  PTG_IDLE = 11,
+  PTG_NADIR = 12,
+  PTG_TARGET = 13,
+  PTG_TARGET_GS = 14,
+  PTG_INERTIAL = 15,
+};
 }
 
 namespace xsc {

mission/system/EiveSystem.cpp

@@ -39,18 +39,22 @@ void EiveSystem::announceMode(bool recursive) {
       modeStr = "POINTING IDLE";
       break;
     }
-    case (acs::AcsMode::PTG_INERTIAL): {
+    case (satsystem::Mode::PTG_NADIR): {
-      modeStr = "POINTING INERTIAL";
+      modeStr = "POINTING NADIR";
       break;
     }
-    case (acs::AcsMode::PTG_TARGET): {
+    case (satsystem::Mode::PTG_TARGET): {
       modeStr = "POINTING TARGET";
       break;
     }
-    case (acs::AcsMode::PTG_TARGET_GS): {
+    case (satsystem::Mode::PTG_TARGET_GS): {
       modeStr = "POINTING TARGET GS";
       break;
     }
+    case (satsystem::Mode::PTG_INERTIAL): {
+      modeStr = "POINTING INERTIAL";
+      break;
+    }
   }
   sif::info << "EIVE system is now in " << modeStr << " mode" << std::endl;
   return Subsystem::announceMode(recursive);

mission/system/acs/DualLaneAssemblyBase.cpp

@@ -183,11 +183,11 @@ void DualLaneAssemblyBase::handleModeTransitionFailed(ReturnValue_t result) {
   // transition to dual mode.
   if (not tryingOtherSide) {
     triggerEvent(CANT_KEEP_MODE, mode, submode);
-    startTransition(mode, nextSubmode);
+    startTransition(targetMode, nextSubmode);
     tryingOtherSide = true;
   } else {
-    triggerEvent(transitionOtherSideFailedEvent, mode, targetSubmode);
+    triggerEvent(transitionOtherSideFailedEvent, targetMode, targetSubmode);
-    startTransition(mode, Submodes::DUAL_MODE);
+    startTransition(targetMode, Submodes::DUAL_MODE);
   }
 }
 
@@ -205,7 +205,8 @@ bool DualLaneAssemblyBase::checkAndHandleRecovery() {
     opCode = pwrStateMachine.fsm();
     if (opCode == OpCodes::TO_OFF_DONE or opCode == OpCodes::TIMEOUT_OCCURED) {
       customRecoveryStates = RecoveryCustomStates::POWER_SWITCHING_ON;
-      pwrStateMachine.start(targetMode, targetSubmode);
+      // Command power back on in any case.
+      pwrStateMachine.start(HasModesIF::MODE_ON, targetSubmode);
     }
   }
   if (customRecoveryStates == POWER_SWITCHING_ON) {

mission/system/systemTree.cpp

@@ -22,6 +22,10 @@ const auto check = subsystem::checkInsert;
 void buildBootSequence(Subsystem& ss, ModeListEntry& eh);
 void buildSafeSequence(Subsystem& ss, ModeListEntry& eh);
 void buildIdleSequence(Subsystem& ss, ModeListEntry& eh);
+void buildPtgNadirSequence(Subsystem& ss, ModeListEntry& eh);
+void buildPtgTargetSequence(Subsystem& ss, ModeListEntry& eh);
+void buildPtgTargetGsSequence(Subsystem& ss, ModeListEntry& eh);
+void buildPtgInertialSequence(Subsystem& ss, ModeListEntry& eh);
 }  // namespace
 
 static const auto OFF = HasModesIF::MODE_OFF;
@@ -40,6 +44,10 @@ void satsystem::init() {
   buildBootSequence(EIVE_SYSTEM, entry);
   buildSafeSequence(EIVE_SYSTEM, entry);
   buildIdleSequence(EIVE_SYSTEM, entry);
+  buildPtgNadirSequence(EIVE_SYSTEM, entry);
+  buildPtgTargetSequence(EIVE_SYSTEM, entry);
+  buildPtgTargetGsSequence(EIVE_SYSTEM, entry);
+  buildPtgInertialSequence(EIVE_SYSTEM, entry);
   EIVE_SYSTEM.setInitialMode(satsystem::Mode::BOOT, 0);
 }
 
@@ -68,88 +76,44 @@ auto EIVE_TABLE_IDLE_TRANS_0 =
 auto EIVE_TABLE_IDLE_TRANS_1 =
     std::make_pair((satsystem::Mode::PTG_IDLE << 24) | 3, FixedArrayList<ModeListEntry, 5>());
 
+auto EIVE_SEQUENCE_PTG_NADIR =
+    std::make_pair(satsystem::Mode::PTG_NADIR, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_NADIR_TGT =
+    std::make_pair((satsystem::Mode::PTG_NADIR << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_NADIR_TRANS_0 =
+    std::make_pair((satsystem::Mode::PTG_NADIR << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_NADIR_TRANS_1 =
+    std::make_pair((satsystem::Mode::PTG_NADIR << 24) | 3, FixedArrayList<ModeListEntry, 5>());
+
+auto EIVE_SEQUENCE_PTG_TARGET =
+    std::make_pair(satsystem::Mode::PTG_TARGET, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_TARGET_TGT =
+    std::make_pair((satsystem::Mode::PTG_TARGET << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_TARGET_TRANS_0 =
+    std::make_pair((satsystem::Mode::PTG_TARGET << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_TARGET_TRANS_1 =
+    std::make_pair((satsystem::Mode::PTG_TARGET << 24) | 3, FixedArrayList<ModeListEntry, 5>());
+
+auto EIVE_SEQUENCE_PTG_TARGET_GS =
+    std::make_pair(satsystem::Mode::PTG_TARGET_GS, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_TARGET_GS_TGT =
+    std::make_pair((satsystem::Mode::PTG_TARGET_GS << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_TARGET_GS_TRANS_0 =
+    std::make_pair((satsystem::Mode::PTG_TARGET_GS << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_TARGET_GS_TRANS_1 =
+    std::make_pair((satsystem::Mode::PTG_TARGET_GS << 24) | 3, FixedArrayList<ModeListEntry, 5>());
+
+auto EIVE_SEQUENCE_PTG_INERTIAL =
+    std::make_pair(satsystem::Mode::PTG_INERTIAL, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_INERTIAL_TGT =
+    std::make_pair((satsystem::Mode::PTG_INERTIAL << 24) | 1, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_INERTIAL_TRANS_0 =
+    std::make_pair((satsystem::Mode::PTG_INERTIAL << 24) | 2, FixedArrayList<ModeListEntry, 5>());
+auto EIVE_TABLE_PTG_INERTIAL_TRANS_1 =
+    std::make_pair((satsystem::Mode::PTG_INERTIAL << 24) | 3, FixedArrayList<ModeListEntry, 5>());
+
 namespace {
 
-void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
-  std::string context = "satsystem::buildSafeSequence";
-  auto ctxc = context.c_str();
-  // Insert Helper Table
-  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table,
-                 bool allowAllSubmodes = false) {
-    eh.setObject(obj);
-    eh.setMode(mode);
-    eh.setSubmode(submode);
-    if (allowAllSubmodes) {
-      eh.allowAllSubmodes();
-    }
-    check(table.insert(eh), ctxc);
-  };
-  // Insert Helper Sequence
-  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
-                 bool checkSuccess) {
-    eh.setTableId(tableId);
-    eh.setWaitSeconds(waitSeconds);
-    eh.setCheckSuccess(checkSuccess);
-    check(sequence.insert(eh), ctxc);
-  };
-
-  // Do no track submode to allow transitions to DETUMBLE submode.
-  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::SAFE, 0, EIVE_TABLE_SAFE_TGT.second, true);
-  iht(objects::PL_SUBSYSTEM, OFF, 0, EIVE_TABLE_SAFE_TGT.second);
-  check(ss.addTable(TableEntry(EIVE_TABLE_SAFE_TGT.first, &EIVE_TABLE_SAFE_TGT.second)), ctxc);
-
-  // Build SAFE transition 0.
-  iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_SAFE_TRANS_0.second);
-  iht(objects::PL_SUBSYSTEM, OFF, 0, EIVE_TABLE_SAFE_TRANS_0.second);
-  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::SAFE, 0, EIVE_TABLE_SAFE_TRANS_0.second, true);
-  check(ss.addTable(TableEntry(EIVE_TABLE_SAFE_TRANS_0.first, &EIVE_TABLE_SAFE_TRANS_0.second)),
-        ctxc);
-
-  // Build Safe sequence
-  ihs(EIVE_SEQUENCE_SAFE.second, EIVE_TABLE_SAFE_TGT.first, 0, false);
-  ihs(EIVE_SEQUENCE_SAFE.second, EIVE_TABLE_SAFE_TRANS_0.first, 0, false);
-  check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_SAFE.first, &EIVE_SEQUENCE_SAFE.second,
-                                     EIVE_SEQUENCE_SAFE.first)),
-        ctxc);
-}
-
-void buildIdleSequence(Subsystem& ss, ModeListEntry& eh) {
-  std::string context = "satsystem::buildIdleSequence";
-  auto ctxc = context.c_str();
-  // Insert Helper Table
-  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
-    eh.setObject(obj);
-    eh.setMode(mode);
-    eh.setSubmode(submode);
-    check(table.insert(eh), ctxc);
-  };
-  // Insert Helper Sequence
-  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
-                 bool checkSuccess) {
-    eh.setTableId(tableId);
-    eh.setWaitSeconds(waitSeconds);
-    eh.setCheckSuccess(checkSuccess);
-    check(sequence.insert(eh), ctxc);
-  };
-
-  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_IDLE, 0, EIVE_TABLE_IDLE_TGT.second);
-  check(ss.addTable(TableEntry(EIVE_TABLE_IDLE_TGT.first, &EIVE_TABLE_IDLE_TGT.second)), ctxc);
-
-  // Build IDLE transition 0
-  iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_IDLE_TRANS_0.second);
-  iht(objects::PL_SUBSYSTEM, OFF, 0, EIVE_TABLE_IDLE_TRANS_0.second);
-  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_IDLE, 0, EIVE_TABLE_IDLE_TRANS_0.second);
-  check(ss.addTable(TableEntry(EIVE_TABLE_IDLE_TRANS_0.first, &EIVE_TABLE_IDLE_TRANS_0.second)),
-        ctxc);
-
-  // Build IDLE sequence
-  ihs(EIVE_SEQUENCE_IDLE.second, EIVE_TABLE_IDLE_TGT.first, 0, false);
-  ihs(EIVE_SEQUENCE_IDLE.second, EIVE_TABLE_IDLE_TRANS_0.first, 0, false);
-  check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_IDLE.first, &EIVE_SEQUENCE_IDLE.second,
-                                     EIVE_SEQUENCE_SAFE.first)),
-        ctxc);
-}
-
 void buildBootSequence(Subsystem& ss, ModeListEntry& eh) {
   std::string context = "satsystem::buildBootSequence";
   auto ctxc = context.c_str();
@@ -194,4 +158,240 @@ void buildBootSequence(Subsystem& ss, ModeListEntry& eh) {
                                      EIVE_SEQUENCE_SAFE.first)),
         ctxc);
 }
+
+void buildSafeSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::buildSafeSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table,
+                 bool allowAllSubmodes = false) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    if (allowAllSubmodes) {
+      eh.allowAllSubmodes();
+    }
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  // Do no track submode to allow transitions to DETUMBLE submode.
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::SAFE, 0, EIVE_TABLE_SAFE_TGT.second, true);
+  check(ss.addTable(TableEntry(EIVE_TABLE_SAFE_TGT.first, &EIVE_TABLE_SAFE_TGT.second)), ctxc);
+
+  // Build SAFE transition 0.
+  iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_SAFE_TRANS_0.second);
+  iht(objects::PL_SUBSYSTEM, OFF, 0, EIVE_TABLE_SAFE_TRANS_0.second);
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::SAFE, 0, EIVE_TABLE_SAFE_TRANS_0.second, true);
+  check(ss.addTable(TableEntry(EIVE_TABLE_SAFE_TRANS_0.first, &EIVE_TABLE_SAFE_TRANS_0.second)),
+        ctxc);
+
+  // Build Safe sequence
+  ihs(EIVE_SEQUENCE_SAFE.second, EIVE_TABLE_SAFE_TGT.first, 0, false);
+  ihs(EIVE_SEQUENCE_SAFE.second, EIVE_TABLE_SAFE_TRANS_0.first, 0, false);
+  check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_SAFE.first, &EIVE_SEQUENCE_SAFE.second,
+                                     EIVE_SEQUENCE_SAFE.first)),
+        ctxc);
+}
+
+void buildIdleSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::buildIdleSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_IDLE, 0, EIVE_TABLE_IDLE_TGT.second);
+  check(ss.addTable(TableEntry(EIVE_TABLE_IDLE_TGT.first, &EIVE_TABLE_IDLE_TGT.second)), ctxc);
+
+  // Build IDLE transition 0
+  iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_IDLE_TRANS_0.second);
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_IDLE, 0, EIVE_TABLE_IDLE_TRANS_0.second);
+  check(ss.addTable(TableEntry(EIVE_TABLE_IDLE_TRANS_0.first, &EIVE_TABLE_IDLE_TRANS_0.second)),
+        ctxc);
+
+  // Build IDLE sequence
+  ihs(EIVE_SEQUENCE_IDLE.second, EIVE_TABLE_IDLE_TGT.first, 0, false);
+  ihs(EIVE_SEQUENCE_IDLE.second, EIVE_TABLE_IDLE_TRANS_0.first, 0, false);
+  check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_IDLE.first, &EIVE_SEQUENCE_IDLE.second,
+                                     EIVE_SEQUENCE_SAFE.first)),
+        ctxc);
+}
+
+void buildPtgNadirSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::buildPtgNadirSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_NADIR, 0, EIVE_TABLE_PTG_NADIR_TGT.second);
+  check(ss.addTable(TableEntry(EIVE_TABLE_PTG_NADIR_TGT.first, &EIVE_TABLE_PTG_NADIR_TGT.second)),
+        ctxc);
+
+  // Build PTG_NADIR transition 0
+  iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_PTG_NADIR_TRANS_0.second);
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_NADIR, 0, EIVE_TABLE_PTG_NADIR_TRANS_0.second);
+  check(ss.addTable(
+            TableEntry(EIVE_TABLE_PTG_NADIR_TRANS_0.first, &EIVE_TABLE_PTG_NADIR_TRANS_0.second)),
+        ctxc);
+
+  // Build PTG_NADIR sequence
+  ihs(EIVE_SEQUENCE_PTG_NADIR.second, EIVE_TABLE_PTG_NADIR_TGT.first, 0, false);
+  ihs(EIVE_SEQUENCE_PTG_NADIR.second, EIVE_TABLE_PTG_NADIR_TRANS_0.first, 0, false);
+  check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_PTG_NADIR.first, &EIVE_SEQUENCE_PTG_NADIR.second,
+                                     EIVE_SEQUENCE_IDLE.first)),
+        ctxc);
+}
+
+void buildPtgTargetSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::buildPtgTargetSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_TARGET, 0, EIVE_TABLE_PTG_TARGET_TGT.second);
+  check(ss.addTable(TableEntry(EIVE_TABLE_PTG_TARGET_TGT.first, &EIVE_TABLE_PTG_TARGET_TGT.second)),
+        ctxc);
+
+  // Build PTG_TARGET transition 0
+  iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_PTG_TARGET_TRANS_0.second);
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_TARGET, 0, EIVE_TABLE_PTG_TARGET_TRANS_0.second);
+  check(ss.addTable(
+            TableEntry(EIVE_TABLE_PTG_TARGET_TRANS_0.first, &EIVE_TABLE_PTG_TARGET_TRANS_0.second)),
+        ctxc);
+
+  // Build PTG_TARGET sequence
+  ihs(EIVE_SEQUENCE_PTG_TARGET.second, EIVE_TABLE_PTG_TARGET_TGT.first, 0, false);
+  ihs(EIVE_SEQUENCE_PTG_TARGET.second, EIVE_TABLE_PTG_TARGET_TRANS_0.first, 0, false);
+  check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_PTG_TARGET.first,
+                                     &EIVE_SEQUENCE_PTG_TARGET.second, EIVE_SEQUENCE_IDLE.first)),
+        ctxc);
+}
+
+void buildPtgTargetGsSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::buildPtgTargetGsSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_TARGET_GS, 0, EIVE_TABLE_PTG_TARGET_GS_TGT.second);
+  check(ss.addTable(
+            TableEntry(EIVE_TABLE_PTG_TARGET_GS_TGT.first, &EIVE_TABLE_PTG_TARGET_GS_TGT.second)),
+        ctxc);
+
+  // Build PTG_TARGET_GS transition 0
+  iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_PTG_TARGET_GS_TRANS_0.second);
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_TARGET_GS, 0,
+      EIVE_TABLE_PTG_TARGET_GS_TRANS_0.second);
+  check(ss.addTable(TableEntry(EIVE_TABLE_PTG_TARGET_GS_TRANS_0.first,
+                               &EIVE_TABLE_PTG_TARGET_GS_TRANS_0.second)),
+        ctxc);
+
+  // Build PTG_TARGET_GS sequence
+  ihs(EIVE_SEQUENCE_PTG_TARGET_GS.second, EIVE_TABLE_PTG_TARGET_GS_TGT.first, 0, false);
+  ihs(EIVE_SEQUENCE_PTG_TARGET_GS.second, EIVE_TABLE_PTG_TARGET_GS_TRANS_0.first, 0, false);
+  check(
+      ss.addSequence(SequenceEntry(EIVE_SEQUENCE_PTG_TARGET_GS.first,
+                                   &EIVE_SEQUENCE_PTG_TARGET_GS.second, EIVE_SEQUENCE_IDLE.first)),
+      ctxc);
+}
+
+void buildPtgInertialSequence(Subsystem& ss, ModeListEntry& eh) {
+  std::string context = "satsystem::buildPtgInertialSequence";
+  auto ctxc = context.c_str();
+  // Insert Helper Table
+  auto iht = [&](object_id_t obj, Mode_t mode, Submode_t submode, ArrayList<ModeListEntry>& table) {
+    eh.setObject(obj);
+    eh.setMode(mode);
+    eh.setSubmode(submode);
+    check(table.insert(eh), ctxc);
+  };
+  // Insert Helper Sequence
+  auto ihs = [&](ArrayList<ModeListEntry>& sequence, Mode_t tableId, uint32_t waitSeconds,
+                 bool checkSuccess) {
+    eh.setTableId(tableId);
+    eh.setWaitSeconds(waitSeconds);
+    eh.setCheckSuccess(checkSuccess);
+    check(sequence.insert(eh), ctxc);
+  };
+
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_INERTIAL, 0, EIVE_TABLE_PTG_INERTIAL_TGT.second);
+  check(ss.addTable(
+            TableEntry(EIVE_TABLE_PTG_INERTIAL_TGT.first, &EIVE_TABLE_PTG_INERTIAL_TGT.second)),
+        ctxc);
+
+  // Build PTG_INERTIAL transition 0
+  iht(objects::TCS_SUBSYSTEM, NML, 0, EIVE_TABLE_PTG_INERTIAL_TRANS_0.second);
+  iht(objects::ACS_SUBSYSTEM, acs::AcsMode::PTG_INERTIAL, 0,
+      EIVE_TABLE_PTG_INERTIAL_TRANS_0.second);
+  check(ss.addTable(TableEntry(EIVE_TABLE_PTG_INERTIAL_TRANS_0.first,
+                               &EIVE_TABLE_PTG_INERTIAL_TRANS_0.second)),
+        ctxc);
+
+  // Build PTG_INERTIAL sequence
+  ihs(EIVE_SEQUENCE_PTG_INERTIAL.second, EIVE_TABLE_PTG_INERTIAL_TGT.first, 0, false);
+  ihs(EIVE_SEQUENCE_PTG_INERTIAL.second, EIVE_TABLE_PTG_INERTIAL_TRANS_0.first, 0, false);
+  check(ss.addSequence(SequenceEntry(EIVE_SEQUENCE_PTG_INERTIAL.first,
+                                     &EIVE_SEQUENCE_PTG_INERTIAL.second, EIVE_SEQUENCE_IDLE.first)),
+        ctxc);
+}
+
 }  // namespace

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) {}