Merge pull request 'Prep v7.2.0' (#816) from prep_v7.2.0 into main

Reviewed-on: #816
Reviewed-by: Marius Eggert <eggertm@irs.uni-stuttgart.de>

CHANGELOG.md

@@ -16,19 +16,52 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
+# [v7.2.0] 2023-10-27
+
+- `eive-tmtc` v5.10.1
+
 ## Added
 
-- CFDP source handler, which allow file downlink using the standardized
+- STR: Added new TM sets: Blob, Blobs, MatchedCentroids, Contrast, AutoBlob, Centroid, Centroids
+- STR: Added new mechanism where the secondary TM which is polled can now be a set instead of
+  being temperature only. An API is exposed which allows to add a data set to that set of secondary
+  telemetry, reset it back to temperature only, and read the whole set. This allows more debugging
+  capability.
+- CFDP source handler, which allows file downlink using the standardized
   CFDP interface.
+- Proper back pressure handling for the CFDP handler, where the `LiveTmTask` is able to throttle
+  the CFDP handler.
+- Added CFDP fault handler events.
+- The EIVE system will command the payload OFF explicitely again when receiving the
+  `power::POWER_LEVEL_CRITICAL` event.
 
 ## Fixed
 
 - If the PTME is driven in a way where it fills faster than it can be emptied, the interface
   can become full during the process of a regular packet write. The interface of the PAPB VC
-  component was adapted to account for this partial success state. The caller must now check
-  for the `PARTIALLY_WRITTEN` state and must take care of finishing a write in some shape or
-  form before starting the next packet transfer.
+  was adapted to be stateful now. Packet generation is started with a `write` call while
+  write transfers are advanced and completed with the `advanceWrite` call if they can not be
+  completed immediately.
+- CFDP Space Packets SSC is now generated properly, was always 0 before.
 - Host build fixes
+- PL Enable set of the power controller is now set to invalid properly if the power controller
+  is not in normal mode.
+- MPSoC debug mode.
+- Possible bugfix for PL PCDU parameter JSON handling which might not have been initialized
+  properly from the JSON file.
+
+## Changed
+
+- Swapped RTD 9 (PLOC HPA Sensor) and RTD 11 (PLOC MPA Sensor) chip select definitions. It is
+  strongly suspected the cables for those devices were swapped during integration. This is probably
+  the easiest way to fix the issue without the need to tweak ground or other OBSW or controller
+  code.
+- Added a 3 second delay in the EIVE system between commanding all PL components except the SUPV,
+  and the SUPV itself OFF when the power level becomes low or critical.
+- SUS FDIR should now trigger less events. The finish event is now only triggered once the
+  SUS has been working properly for a minute again. It will then display the number of periods
+  during which the SUS was not working as well as the maximum amount of invalid messages.
+- Updated battery internal resistance to new value
 
 # [v7.1.0] 2023-10-11
 

CMakeLists.txt

@@ -10,7 +10,7 @@
 cmake_minimum_required(VERSION 3.13)
 
 set(OBSW_VERSION_MAJOR 7)
-set(OBSW_VERSION_MINOR 1)
+set(OBSW_VERSION_MINOR 2)
 set(OBSW_VERSION_REVISION 0)
 
 # set(CMAKE_VERBOSE TRUE)

bsp_hosted/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 314 translations.
+ * @brief    Auto-generated event translation file. Contains 315 translations.
  * @details
- * Generated on: 2023-10-13 09:44:05
+ * Generated on: 2023-10-27 14:24:05
  */
 #include "translateEvents.h"
 
@@ -319,6 +319,7 @@ const char *DUMP_HK_CANCELLED_STRING = "DUMP_HK_CANCELLED";
 const char *DUMP_CFDP_CANCELLED_STRING = "DUMP_CFDP_CANCELLED";
 const char *TEMPERATURE_ALL_ONES_START_STRING = "TEMPERATURE_ALL_ONES_START";
 const char *TEMPERATURE_ALL_ONES_RECOVERY_STRING = "TEMPERATURE_ALL_ONES_RECOVERY";
+const char *FAULT_HANDLER_TRIGGERED_STRING = "FAULT_HANDLER_TRIGGERED";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -950,6 +951,8 @@ const char *translateEvents(Event event) {
       return TEMPERATURE_ALL_ONES_START_STRING;
     case (14501):
       return TEMPERATURE_ALL_ONES_RECOVERY_STRING;
+    case (14600):
+      return FAULT_HANDLER_TRIGGERED_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

bsp_hosted/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 174 translations.
- * Generated on: 2023-10-13 09:44:05
+ * Contains 175 translations.
+ * Generated on: 2023-10-27 14:24:05
  */
 #include "translateObjects.h"
 
@@ -161,6 +161,7 @@ const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
 const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
 const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
 const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
+const char *CFDP_FAULT_HANDLER_STRING = "CFDP_FAULT_HANDLER";
 const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
 const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
@@ -493,6 +494,8 @@ const char *translateObject(object_id_t object) {
       return CFDP_HANDLER_STRING;
     case 0x73000206:
       return CFDP_DISTRIBUTOR_STRING;
+    case 0x73000207:
+      return CFDP_FAULT_HANDLER_STRING;
     case 0x73010000:
       return EIVE_SYSTEM_STRING;
     case 0x73010001:

bsp_q7s/objectFactory.cpp

@@ -750,14 +750,18 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
   gpioChecker(args.gpioComIF.addGpios(gpioCookiePtmeIp), "PTME PAPB VCs");
 
   // Creating virtual channel interfaces
-  VirtualChannelIF* vc0 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_EMPTY,
-                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC0);
-  VirtualChannelIF* vc1 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_EMPTY,
-                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC1);
-  VirtualChannelIF* vc2 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_EMPTY,
-                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC2);
-  VirtualChannelIF* vc3 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_EMPTY,
-                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC3);
+  VirtualChannelIF* vc0 =
+      new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_EMPTY, q7s::UIO_PTME,
+                          q7s::uiomapids::PTME_VC0, config::MAX_SPACEPACKET_TC_SIZE);
+  VirtualChannelIF* vc1 =
+      new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_EMPTY, q7s::UIO_PTME,
+                          q7s::uiomapids::PTME_VC1, config::MAX_SPACEPACKET_TC_SIZE);
+  VirtualChannelIF* vc2 =
+      new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_EMPTY, q7s::UIO_PTME,
+                          q7s::uiomapids::PTME_VC2, config::MAX_SPACEPACKET_TC_SIZE);
+  VirtualChannelIF* vc3 =
+      new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_EMPTY, q7s::UIO_PTME,
+                          q7s::uiomapids::PTME_VC3, config::MAX_SPACEPACKET_TC_SIZE);
   // Creating ptme object and adding virtual channel interfaces
   Ptme* ptme = new Ptme(objects::PTME);
   ptme->addVcInterface(ccsds::VC0, vc0);

common/config/devices/addresses.h

@@ -54,6 +54,9 @@ enum I2cAddress : address_t {
 };
 
 enum spiAddresses : address_t {
+  RTD_IC_0,
+  RTD_IC_1,
+  RTD_IC_2,
   RTD_IC_3,
   RTD_IC_4,
   RTD_IC_5,
@@ -67,9 +70,6 @@ enum spiAddresses : address_t {
   RTD_IC_13,
   RTD_IC_14,
   RTD_IC_15,
-  RTD_IC_16,
-  RTD_IC_17,
-  RTD_IC_18,
   RW1,
   RW2,
   RW3,

common/config/devices/gpioIds.h

@@ -37,6 +37,9 @@ enum gpioId_t {
   TEST_ID_0,
   TEST_ID_1,
 
+  RTD_IC_0,
+  RTD_IC_1,
+  RTD_IC_2,
   RTD_IC_3,
   RTD_IC_4,
   RTD_IC_5,
@@ -50,9 +53,6 @@ enum gpioId_t {
   RTD_IC_13,
   RTD_IC_14,
   RTD_IC_15,
-  RTD_IC_16,
-  RTD_IC_17,
-  RTD_IC_18,
 
   CS_SUS_0,
   CS_SUS_1,

common/config/eive/definitions.h

@@ -35,6 +35,8 @@ static constexpr uint32_t STR_IMG_HELPER_QUEUE_SIZE = 50;
 
 static constexpr uint8_t LIVE_TM = 0;
 
+static constexpr size_t MAX_SPACEPACKET_TC_SIZE = 2048;
+
 /* Limits for filename and path checks */
 static constexpr uint32_t MAX_PATH_SIZE = 200;
 static constexpr uint32_t MAX_FILENAME_SIZE = 100;
@@ -48,7 +50,7 @@ static constexpr uint32_t LEGACY_SA_DEPL_CHANNEL_ALTERNATION_INTERVAL_SECS = 5;
 // Maximum allowed burn time allowed by the software.
 static constexpr uint32_t SA_DEPL_MAX_BURN_TIME = 180;
 
-static constexpr size_t CFDP_MAX_FILE_SEGMENT_LEN = 990;
+static constexpr size_t CFDP_MAX_FILE_SEGMENT_LEN = 900;
 
 static constexpr uint32_t CCSDS_HANDLER_QUEUE_SIZE = 50;
 static constexpr uint8_t NUMBER_OF_VIRTUAL_CHANNELS = 4;
@@ -61,23 +63,22 @@ static constexpr uint32_t HK_STORE_QUEUE_SIZE = 300;
 static constexpr uint32_t CFDP_STORE_QUEUE_SIZE = 300;
 
 static constexpr uint32_t LIVE_CHANNEL_NORMAL_QUEUE_SIZE = 250;
-static constexpr uint32_t LIVE_CHANNEL_CFDP_QUEUE_SIZE = 400;
+static constexpr uint32_t LIVE_CHANNEL_CFDP_QUEUE_SIZE = 350;
 
-static constexpr uint32_t CFDP_THROTTLE_PERIOD_MS = 200;
-static constexpr uint32_t CFDP_MAX_FSM_CALL_COUNT_SRC_HANDLER = 20;
+static constexpr uint32_t CFDP_MAX_FSM_CALL_COUNT_SRC_HANDLER = 10;
 static constexpr uint32_t CFDP_MAX_FSM_CALL_COUNT_DEST_HANDLER = 300;
-static constexpr uint32_t CFDP_SHORT_DELAY_MS = 50;
+static constexpr uint32_t CFDP_SHORT_DELAY_MS = 40;
 static constexpr uint32_t CFDP_REGULAR_DELAY_MS = 200;
 
 static constexpr uint32_t MAX_PUS_FUNNEL_QUEUE_DEPTH = 100;
-static constexpr uint32_t MAX_CFDP_FUNNEL_QUEUE_DEPTH = 150;
+static constexpr uint32_t MAX_CFDP_FUNNEL_QUEUE_DEPTH = LIVE_CHANNEL_CFDP_QUEUE_SIZE;
 static constexpr uint32_t VERIFICATION_SERVICE_QUEUE_DEPTH = 120;
 static constexpr uint32_t HK_SERVICE_QUEUE_DEPTH = 60;
 static constexpr uint32_t ACTION_SERVICE_QUEUE_DEPTH = 60;
 
 static constexpr uint32_t UDP_MAX_STORED_CMDS = 200;
 static constexpr uint32_t UDP_MSG_QUEUE_DEPTH = UDP_MAX_STORED_CMDS;
-static constexpr uint32_t TCP_MAX_STORED_CMDS = 300;
+static constexpr uint32_t TCP_MAX_STORED_CMDS = 350;
 static constexpr uint32_t TCP_MSG_QUEUE_DEPTH = TCP_MAX_STORED_CMDS;
 static constexpr uint32_t TCP_MAX_NUMBER_TMS_SENT_PER_CYCLE = TCP_MSG_QUEUE_DEPTH;
 

common/config/eive/eventSubsystemIds.h

@@ -41,6 +41,7 @@ enum : uint8_t {
   PERSISTENT_TM_STORE = 143,
   SYRLINKS_COM = 144,
   SUS_HANDLER = 145,
+  CFDP_APP = 146,
   COMMON_SUBSYSTEM_ID_END
 
 };

common/config/eive/objects.h

@@ -166,6 +166,7 @@ enum commonObjects : uint32_t {
   CFDP_TM_FUNNEL = 0x73000102,
   CFDP_HANDLER = 0x73000205,
   CFDP_DISTRIBUTOR = 0x73000206,
+  CFDP_FAULT_HANDLER = 0x73000207,
   MISC_TM_STORE = 0x73020001,
   OK_TM_STORE = 0x73020002,
   NOT_OK_TM_STORE = 0x73020003,

generators/bsp_hosted_events.csv

@@ -312,4 +312,5 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14313;0x37e9;DUMP_HK_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14314;0x37ea;DUMP_CFDP_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14500;0x38a4;TEMPERATURE_ALL_ONES_START;MEDIUM;Detected invalid values, starting invalid message counting;mission/acs/SusHandler.h
-14501;0x38a5;TEMPERATURE_ALL_ONES_RECOVERY;INFO;Detected valid values again, resetting invalid message counter. P1: Invalid message counter.;mission/acs/SusHandler.h
+14501;0x38a5;TEMPERATURE_ALL_ONES_RECOVERY;INFO;Detected valid values for a prolonged time again, resetting all counters. P1: Number of periods with invalid messages. P2: Maximum invalid message counter.;mission/acs/SusHandler.h
+14600;0x3908;FAULT_HANDLER_TRIGGERED;LOW;P1: CFDP fault handler code. P2: CFDP condition code.;mission/cfdp/defs.h

generators/bsp_hosted_objects.csv

@@ -153,6 +153,7 @@
 0x73000102;CFDP_TM_FUNNEL
 0x73000205;CFDP_HANDLER
 0x73000206;CFDP_DISTRIBUTOR
+0x73000207;CFDP_FAULT_HANDLER
 0x73010000;EIVE_SYSTEM
 0x73010001;ACS_SUBSYSTEM
 0x73010002;PL_SUBSYSTEM

generators/bsp_hosted_returnvalues.csv

@@ -521,5 +521,5 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x6e01;PTM_BusyDumping;No description;1;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
 0x6f00;TMS_IsBusy;No description;0;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x6f01;TMS_PartiallyWritten;No description;1;TM_SINK;mission/tmtc/DirectTmSinkIF.h
-0x6f02;TMS_IncompletePartialWrite;No description;2;TM_SINK;mission/tmtc/DirectTmSinkIF.h
+0x6f02;TMS_NoWriteActive;No description;2;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x7000;VCS_ChannelDoesNotExist;No description;0;VIRTUAL_CHANNEL;mission/com/VirtualChannel.h

generators/bsp_hosted_subsystems.csv

@@ -61,3 +61,4 @@
 143;PERSISTENT_TM_STORE
 144;SYRLINKS_COM
 145;SUS_HANDLER
+146;CFDP_APP

generators/bsp_q7s_events.csv

@@ -312,4 +312,5 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14313;0x37e9;DUMP_HK_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14314;0x37ea;DUMP_CFDP_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14500;0x38a4;TEMPERATURE_ALL_ONES_START;MEDIUM;Detected invalid values, starting invalid message counting;mission/acs/SusHandler.h
-14501;0x38a5;TEMPERATURE_ALL_ONES_RECOVERY;INFO;Detected valid values again, resetting invalid message counter. P1: Invalid message counter.;mission/acs/SusHandler.h
+14501;0x38a5;TEMPERATURE_ALL_ONES_RECOVERY;INFO;Detected valid values for a prolonged time again, resetting all counters. P1: Number of periods with invalid messages. P2: Maximum invalid message counter.;mission/acs/SusHandler.h
+14600;0x3908;FAULT_HANDLER_TRIGGERED;LOW;P1: CFDP fault handler code. P2: CFDP condition code.;mission/cfdp/defs.h

generators/bsp_q7s_objects.csv

@@ -158,6 +158,7 @@
 0x73000102;CFDP_TM_FUNNEL
 0x73000205;CFDP_HANDLER
 0x73000206;CFDP_DISTRIBUTOR
+0x73000207;CFDP_FAULT_HANDLER
 0x73010000;EIVE_SYSTEM
 0x73010001;ACS_SUBSYSTEM
 0x73010002;PL_SUBSYSTEM

generators/bsp_q7s_returnvalues.csv

@@ -616,6 +616,6 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x6e01;PTM_BusyDumping;No description;1;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
 0x6f00;TMS_IsBusy;No description;0;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x6f01;TMS_PartiallyWritten;No description;1;TM_SINK;mission/tmtc/DirectTmSinkIF.h
-0x6f02;TMS_IncompletePartialWrite;No description;2;TM_SINK;mission/tmtc/DirectTmSinkIF.h
+0x6f02;TMS_NoWriteActive;No description;2;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x7000;VCS_ChannelDoesNotExist;No description;0;VIRTUAL_CHANNEL;mission/com/VirtualChannel.h
 0x7200;SCBU_KeyNotFound;No description;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h

generators/bsp_q7s_subsystems.csv

@@ -61,3 +61,4 @@
 143;PERSISTENT_TM_STORE
 144;SYRLINKS_COM
 145;SUS_HANDLER
+146;CFDP_APP

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 314 translations.
+ * @brief    Auto-generated event translation file. Contains 315 translations.
  * @details
- * Generated on: 2023-10-13 09:44:05
+ * Generated on: 2023-10-27 14:24:05
  */
 #include "translateEvents.h"
 
@@ -319,6 +319,7 @@ const char *DUMP_HK_CANCELLED_STRING = "DUMP_HK_CANCELLED";
 const char *DUMP_CFDP_CANCELLED_STRING = "DUMP_CFDP_CANCELLED";
 const char *TEMPERATURE_ALL_ONES_START_STRING = "TEMPERATURE_ALL_ONES_START";
 const char *TEMPERATURE_ALL_ONES_RECOVERY_STRING = "TEMPERATURE_ALL_ONES_RECOVERY";
+const char *FAULT_HANDLER_TRIGGERED_STRING = "FAULT_HANDLER_TRIGGERED";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -950,6 +951,8 @@ const char *translateEvents(Event event) {
       return TEMPERATURE_ALL_ONES_START_STRING;
     case (14501):
       return TEMPERATURE_ALL_ONES_RECOVERY_STRING;
+    case (14600):
+      return FAULT_HANDLER_TRIGGERED_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

generators/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 178 translations.
- * Generated on: 2023-10-13 09:44:05
+ * Contains 179 translations.
+ * Generated on: 2023-10-27 14:24:05
  */
 #include "translateObjects.h"
 
@@ -166,6 +166,7 @@ const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
 const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
 const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
 const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
+const char *CFDP_FAULT_HANDLER_STRING = "CFDP_FAULT_HANDLER";
 const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
 const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
@@ -507,6 +508,8 @@ const char *translateObject(object_id_t object) {
       return CFDP_HANDLER_STRING;
     case 0x73000206:
       return CFDP_DISTRIBUTOR_STRING;
+    case 0x73000207:
+      return CFDP_FAULT_HANDLER_STRING;
     case 0x73010000:
       return EIVE_SYSTEM_STRING;
     case 0x73010001:

linux/ObjectFactory.cpp

@@ -206,74 +206,78 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
 
   GpioCallback* gpioRtdIc0 = new GpioCallback("Chip select RTD IC0", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_3, gpioRtdIc0);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_0, gpioRtdIc0);
   GpioCallback* gpioRtdIc1 = new GpioCallback("Chip select RTD IC1", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_4, gpioRtdIc1);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_1, gpioRtdIc1);
   GpioCallback* gpioRtdIc2 = new GpioCallback("Chip select RTD IC2", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_5, gpioRtdIc2);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_2, gpioRtdIc2);
   GpioCallback* gpioRtdIc3 = new GpioCallback("Chip select RTD IC3", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_6, gpioRtdIc3);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_3, gpioRtdIc3);
   GpioCallback* gpioRtdIc4 = new GpioCallback("Chip select RTD IC4", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_7, gpioRtdIc4);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_4, gpioRtdIc4);
   GpioCallback* gpioRtdIc5 = new GpioCallback("Chip select RTD IC5", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_8, gpioRtdIc5);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_5, gpioRtdIc5);
   GpioCallback* gpioRtdIc6 = new GpioCallback("Chip select RTD IC6", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_9, gpioRtdIc6);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_6, gpioRtdIc6);
   GpioCallback* gpioRtdIc7 = new GpioCallback("Chip select RTD IC7", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_10, gpioRtdIc7);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_7, gpioRtdIc7);
   GpioCallback* gpioRtdIc8 = new GpioCallback("Chip select RTD IC8", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_11, gpioRtdIc8);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_8, gpioRtdIc8);
   GpioCallback* gpioRtdIc9 = new GpioCallback("Chip select RTD IC9", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_12, gpioRtdIc9);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_9, gpioRtdIc9);
   GpioCallback* gpioRtdIc10 = new GpioCallback("Chip select RTD IC10", Direction::OUT, Levels::HIGH,
                                                &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_13, gpioRtdIc10);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_10, gpioRtdIc10);
   GpioCallback* gpioRtdIc11 = new GpioCallback("Chip select RTD IC11", Direction::OUT, Levels::HIGH,
                                                &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_14, gpioRtdIc11);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_11, gpioRtdIc11);
   GpioCallback* gpioRtdIc12 = new GpioCallback("Chip select RTD IC12", Direction::OUT, Levels::HIGH,
                                                &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_15, gpioRtdIc12);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_12, gpioRtdIc12);
   GpioCallback* gpioRtdIc13 = new GpioCallback("Chip select RTD IC13", Direction::OUT, Levels::HIGH,
                                                &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_16, gpioRtdIc13);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_13, gpioRtdIc13);
   GpioCallback* gpioRtdIc14 = new GpioCallback("Chip select RTD IC14", Direction::OUT, Levels::HIGH,
                                                &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_17, gpioRtdIc14);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_14, gpioRtdIc14);
   GpioCallback* gpioRtdIc15 = new GpioCallback("Chip select RTD IC15", Direction::OUT, Levels::HIGH,
                                                &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_18, gpioRtdIc15);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_15, gpioRtdIc15);
 
   gpioChecker(gpioComIF->addGpios(rtdGpioCookie), "RTDs");
 
 #if OBSW_ADD_RTD_DEVICES == 1
   using namespace EiveMax31855;
+  // ! NOTE !
+  // The chip selects for device 9 and 11 are swapped here. It is strongly suspected the cables
+  // for those devices were swapped during integration. This is probably the easiest way to
+  // fix the issue.
   std::array<std::pair<address_t, gpioId_t>, NUM_RTDS> cookieArgs = {{
+      {addresses::RTD_IC_0, gpioIds::RTD_IC_0},
+      {addresses::RTD_IC_1, gpioIds::RTD_IC_1},
+      {addresses::RTD_IC_2, gpioIds::RTD_IC_2},
       {addresses::RTD_IC_3, gpioIds::RTD_IC_3},
       {addresses::RTD_IC_4, gpioIds::RTD_IC_4},
       {addresses::RTD_IC_5, gpioIds::RTD_IC_5},
       {addresses::RTD_IC_6, gpioIds::RTD_IC_6},
       {addresses::RTD_IC_7, gpioIds::RTD_IC_7},
       {addresses::RTD_IC_8, gpioIds::RTD_IC_8},
-      {addresses::RTD_IC_9, gpioIds::RTD_IC_9},
-      {addresses::RTD_IC_10, gpioIds::RTD_IC_10},
       {addresses::RTD_IC_11, gpioIds::RTD_IC_11},
+      {addresses::RTD_IC_10, gpioIds::RTD_IC_10},
+      {addresses::RTD_IC_9, gpioIds::RTD_IC_9},
       {addresses::RTD_IC_12, gpioIds::RTD_IC_12},
       {addresses::RTD_IC_13, gpioIds::RTD_IC_13},
       {addresses::RTD_IC_14, gpioIds::RTD_IC_14},
       {addresses::RTD_IC_15, gpioIds::RTD_IC_15},
-      {addresses::RTD_IC_16, gpioIds::RTD_IC_16},
-      {addresses::RTD_IC_17, gpioIds::RTD_IC_17},
-      {addresses::RTD_IC_18, gpioIds::RTD_IC_18},
   }};
   // HSPD: Heatspreader
 

linux/callbacks/gpioCallbacks.cpp

@@ -21,6 +21,18 @@ void gpioCallbacks::spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gp
 
   if (value == gpio::Levels::HIGH) {
     switch (gpioId) {
+      case (gpioIds::RTD_IC_0): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_1): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_2): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
       case (gpioIds::RTD_IC_3): {
         disableDecoderTcsIc1(gpioIF);
         break;
@@ -42,15 +54,15 @@ void gpioCallbacks::spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gp
         break;
       }
       case (gpioIds::RTD_IC_8): {
-        disableDecoderTcsIc1(gpioIF);
+        disableDecoderTcsIc2(gpioIF);
         break;
       }
       case (gpioIds::RTD_IC_9): {
-        disableDecoderTcsIc1(gpioIF);
+        disableDecoderTcsIc2(gpioIF);
         break;
       }
       case (gpioIds::RTD_IC_10): {
-        disableDecoderTcsIc1(gpioIF);
+        disableDecoderTcsIc2(gpioIF);
         break;
       }
       case (gpioIds::RTD_IC_11): {
@@ -73,18 +85,6 @@ void gpioCallbacks::spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gp
         disableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_16): {
-        disableDecoderTcsIc2(gpioIF);
-        break;
-      }
-      case (gpioIds::RTD_IC_17): {
-        disableDecoderTcsIc2(gpioIF);
-        break;
-      }
-      case (gpioIds::RTD_IC_18): {
-        disableDecoderTcsIc2(gpioIF);
-        break;
-      }
       case (gpioIds::CS_SUS_0): {
         disableDecoderInterfaceBoardIc1(gpioIF);
         break;
@@ -154,82 +154,82 @@ void gpioCallbacks::spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gp
     }
   } else if (value == gpio::Levels::LOW) {
     switch (gpioId) {
-      case (gpioIds::RTD_IC_3): {
+      case (gpioIds::RTD_IC_0): {
         selectY7(gpioIF);
         enableDecoderTcsIc1(gpioIF);
         break;
       }
+      case (gpioIds::RTD_IC_1): {
+        selectY6(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_2): {
+        selectY5(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_3): {
+        selectY4(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
       case (gpioIds::RTD_IC_4): {
-        selectY6(gpioIF);
+        selectY3(gpioIF);
         enableDecoderTcsIc1(gpioIF);
         break;
       }
       case (gpioIds::RTD_IC_5): {
-        selectY5(gpioIF);
+        selectY2(gpioIF);
         enableDecoderTcsIc1(gpioIF);
         break;
       }
       case (gpioIds::RTD_IC_6): {
-        selectY4(gpioIF);
+        selectY1(gpioIF);
         enableDecoderTcsIc1(gpioIF);
         break;
       }
       case (gpioIds::RTD_IC_7): {
-        selectY3(gpioIF);
-        enableDecoderTcsIc1(gpioIF);
-        break;
-      }
-      case (gpioIds::RTD_IC_8): {
-        selectY2(gpioIF);
-        enableDecoderTcsIc1(gpioIF);
-        break;
-      }
-      case (gpioIds::RTD_IC_9): {
-        selectY1(gpioIF);
-        enableDecoderTcsIc1(gpioIF);
-        break;
-      }
-      case (gpioIds::RTD_IC_10): {
         selectY0(gpioIF);
         enableDecoderTcsIc1(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_11): {
+      case (gpioIds::RTD_IC_8): {
         selectY7(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_12): {
+      case (gpioIds::RTD_IC_9): {
         selectY6(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_13): {
+      case (gpioIds::RTD_IC_10): {
         selectY5(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_14): {
+      case (gpioIds::RTD_IC_11): {
         selectY4(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_15): {
+      case (gpioIds::RTD_IC_12): {
         selectY3(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_16): {
+      case (gpioIds::RTD_IC_13): {
         selectY2(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_17): {
+      case (gpioIds::RTD_IC_14): {
         selectY1(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;
       }
-      case (gpioIds::RTD_IC_18): {
+      case (gpioIds::RTD_IC_15): {
         selectY0(gpioIF);
         enableDecoderTcsIc2(gpioIF);
         break;

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 314 translations.
+ * @brief    Auto-generated event translation file. Contains 315 translations.
  * @details
- * Generated on: 2023-10-13 09:44:05
+ * Generated on: 2023-10-27 14:24:05
  */
 #include "translateEvents.h"
 
@@ -319,6 +319,7 @@ const char *DUMP_HK_CANCELLED_STRING = "DUMP_HK_CANCELLED";
 const char *DUMP_CFDP_CANCELLED_STRING = "DUMP_CFDP_CANCELLED";
 const char *TEMPERATURE_ALL_ONES_START_STRING = "TEMPERATURE_ALL_ONES_START";
 const char *TEMPERATURE_ALL_ONES_RECOVERY_STRING = "TEMPERATURE_ALL_ONES_RECOVERY";
+const char *FAULT_HANDLER_TRIGGERED_STRING = "FAULT_HANDLER_TRIGGERED";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -950,6 +951,8 @@ const char *translateEvents(Event event) {
       return TEMPERATURE_ALL_ONES_START_STRING;
     case (14501):
       return TEMPERATURE_ALL_ONES_RECOVERY_STRING;
+    case (14600):
+      return FAULT_HANDLER_TRIGGERED_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

linux/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 178 translations.
- * Generated on: 2023-10-13 09:44:05
+ * Contains 179 translations.
+ * Generated on: 2023-10-27 14:24:05
  */
 #include "translateObjects.h"
 
@@ -166,6 +166,7 @@ const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
 const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
 const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
 const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
+const char *CFDP_FAULT_HANDLER_STRING = "CFDP_FAULT_HANDLER";
 const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
 const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
@@ -507,6 +508,8 @@ const char *translateObject(object_id_t object) {
       return CFDP_HANDLER_STRING;
     case 0x73000206:
       return CFDP_DISTRIBUTOR_STRING;
+    case 0x73000207:
+      return CFDP_FAULT_HANDLER_STRING;
     case 0x73010000:
       return EIVE_SYSTEM_STRING;
     case 0x73010001:

linux/ipcore/PapbVcInterface.cpp

@@ -8,8 +8,12 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
 PapbVcInterface::PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId,
-                                 std::string uioFile, int mapNum)
-    : gpioComIF(gpioComIF), papbEmptyId(papbEmptyId), uioFile(std::move(uioFile)), mapNum(mapNum) {}
+                                 std::string uioFile, int mapNum, size_t maxPacketSize)
+    : gpioComIF(gpioComIF),
+      papbEmptyId(papbEmptyId),
+      packetBuf(maxPacketSize),
+      uioFile(std::move(uioFile)),
+      mapNum(mapNum) {}
 
 PapbVcInterface::~PapbVcInterface() {}
 
@@ -28,28 +32,31 @@ ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size, size_t& w
   if (size < 4) {
     return returnvalue::FAILED;
   }
-  // The user must call finishWrite before starting a new packet transfer.
-  if (partialWriteActive) {
-    return INCOMPLETE_PARTIAL_WRITE;
+  // The user must call advance until completion before starting a new packet transfer.
+  if (writeActiveStatus) {
+    return IS_BUSY;
   }
+  if (size > packetBuf.capacity()) {
+    sif::error << "PapbVcInterface: Packet with size " << size << " larger than maximum configured"
+               << " byte size " << packetBuf.capacity() << std::endl;
+    return returnvalue::FAILED;
+  }
+  std::memcpy(packetBuf.data(), data, size);
+  currentPacketSize = size;
+  currentPacketIndex = 0;
   if (pollReadyForPacket()) {
     startPacketTransfer(ByteWidthCfg::ONE);
   } else {
     return DirectTmSinkIF::IS_BUSY;
   }
-  if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
-    abortPacketTransfer();
-    return returnvalue::FAILED;
-  }
-  return finishWriteInternal(data, 0, size, writtenSize, false);
+  return advanceWrite(writtenSize);
 }
 
 void PapbVcInterface::startPacketTransfer(ByteWidthCfg initWidth) {
   *vcBaseReg = CONFIG_DATA_INPUT | initWidth;
+  writeActiveStatus = true;
 }
 
-void PapbVcInterface::completePacketTransfer() { *vcBaseReg = CONFIG_END; }
-
 bool PapbVcInterface::pollReadyForPacket() const {
   //  Check if PAPB interface is ready to receive data. Use the configuration register for this.
   //  Bit 5, see PTME ptme_001_01-0-7-r2 Table 31.
@@ -57,34 +64,23 @@ bool PapbVcInterface::pollReadyForPacket() const {
   return (reg >> 6) & 0b1;
 }
 
-ReturnValue_t PapbVcInterface::finishWrite(const uint8_t* data, size_t start,
-                                           size_t remainingSize) {
-  if (not pollReadyForPacket()) {
-    return returnvalue::FAILED;
+ReturnValue_t PapbVcInterface::advanceWrite(size_t& writtenSize) {
+  if (!writeActiveStatus) {
+    return NO_WRITE_ACTIVE;
   }
-  size_t dummy = 0;
-  return finishWriteInternal(data, start, remainingSize, dummy, true);
-}
-
-ReturnValue_t PapbVcInterface::finishWriteInternal(const uint8_t* data, size_t start,
-                                                   size_t remainingSize, size_t& writtenSize,
-                                                   bool abortOnPartialWrite) {
-  for (size_t idx = 0; idx < remainingSize; idx++) {
+  if (not pollReadyForPacket()) {
+    return IS_BUSY;
+  }
+  while (currentPacketIndex < currentPacketSize) {
     if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
       if (not pollReadyForPacket()) {
-        writtenSize = start + idx;
-        partialWriteActive = true;
-        if (abortOnPartialWrite) {
-          abortPacketTransfer();
-          partialWriteActive = false;
-          return returnvalue::FAILED;
-        }
         return PARTIALLY_WRITTEN;
       }
       abortPacketTransfer();
       return returnvalue::FAILED;
     }
-    *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[start + idx]);
+    *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(packetBuf[currentPacketIndex++]);
+    writtenSize++;
   }
   if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
     abortPacketTransfer();
@@ -94,6 +90,8 @@ ReturnValue_t PapbVcInterface::finishWriteInternal(const uint8_t* data, size_t s
   return returnvalue::OK;
 }
 
+bool PapbVcInterface::writeActive() const { return writeActiveStatus; }
+
 bool PapbVcInterface::isVcInterfaceBufferEmpty() {
   ReturnValue_t result = returnvalue::OK;
   gpio::Levels papbEmptyState = gpio::Levels::HIGH;
@@ -130,4 +128,16 @@ inline bool PapbVcInterface::pollReadyForOctet(uint32_t maxCycles) const {
   return false;
 }
 
-void PapbVcInterface::abortPacketTransfer() { *vcBaseReg = CONFIG_ABORT; }
+void PapbVcInterface::abortPacketTransfer() {
+  *vcBaseReg = CONFIG_ABORT;
+  writeActiveStatus = false;
+  currentPacketIndex = 0;
+  currentPacketSize = 0;
+}
+
+void PapbVcInterface::completePacketTransfer() {
+  *vcBaseReg = CONFIG_END;
+  writeActiveStatus = false;
+  currentPacketIndex = 0;
+  currentPacketSize = 0;
+}

linux/ipcore/PapbVcInterface.h

@@ -6,6 +6,7 @@
 #include <linux/ipcore/VirtualChannelIF.h>
 
 #include <atomic>
+#include <vector>
 
 #include "OBSWConfig.h"
 #include "fsfw/returnvalues/returnvalue.h"
@@ -30,24 +31,22 @@ class PapbVcInterface : public VirtualChannelIF {
    * @param uioFile       UIO file providing access to the PAPB bus
    * @param mapNum        Map number of UIO map associated with this virtual channel
    */
-  PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId, std::string uioFile, int mapNum);
+  PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId, std::string uioFile, int mapNum,
+                  size_t maxPacketSize);
   virtual ~PapbVcInterface();
 
+  // See interface function documentation for docs on these functions.
+
   bool isBusy() const override;
-  /**
-   *
-   * @param data
-   * @param size
-   * @return returnvalue::OK on successfull write, PAPB_BUSY if PAPB is busy.
-   */
+
   ReturnValue_t write(const uint8_t* data, size_t size, size_t& writtenSize) override;
 
-  ReturnValue_t finishWrite(const uint8_t* data, size_t start, size_t remainingSize) override;
-  ReturnValue_t finishWriteInternal(const uint8_t* data, size_t start, size_t remainingSize,
-                                    size_t& writtenSize, bool abortOnPartialWrite);
+  ReturnValue_t advanceWrite(size_t& remainingSize) override;
 
   void cancelTransfer() override;
 
+  bool writeActive() const override;
+
   ReturnValue_t initialize() override;
 
  private:
@@ -90,12 +89,14 @@ class PapbVcInterface : public VirtualChannelIF {
   /** High when external buffer memory of virtual channel is empty */
   gpioId_t papbEmptyId = gpio::NO_GPIO;
 
+  std::vector<uint8_t> packetBuf;
   std::string uioFile;
   int mapNum = 0;
-  bool partialWriteActive = false;
+  bool writeActiveStatus = false;
+  size_t currentPacketIndex = 0;
+  size_t currentPacketSize = 0;
   mutable struct timespec nextDelay = {.tv_sec = 0, .tv_nsec = 0};
   const struct timespec BETWEEN_POLL_DELAY = {.tv_sec = 0, .tv_nsec = 10};
-  mutable struct timespec remDelay;
 
   volatile uint32_t* vcBaseReg = nullptr;
 

linux/payload/PlocMpsocHandler.cpp

@@ -91,6 +91,8 @@ ReturnValue_t PlocMpsocHandler::initialize() {
 
 void PlocMpsocHandler::performOperationHook() {
   if (commandIsPending and cmdCountdown.hasTimedOut()) {
+    sif::warning << "PlocMpsocHandler: Command " << getPendingCommand() << " has timed out"
+                 << std::endl;
     commandIsPending = false;
     // TODO: Better returnvalue?
     cmdDoneHandler(false, returnvalue::FAILED);
@@ -215,7 +217,6 @@ ReturnValue_t PlocMpsocHandler::buildNormalDeviceCommand(DeviceCommandId_t* id)
   if (not commandIsPending and not specialComHelperExecuting) {
     *id = mpsoc::TC_GET_HK_REPORT;
     commandIsPending = true;
-    cmdCountdown.resetTimer();
     return buildCommandFromCommand(*id, nullptr, 0);
   }
   return NOTHING_TO_SEND;
@@ -352,6 +353,11 @@ ReturnValue_t PlocMpsocHandler::scanForReply(const uint8_t* start, size_t remain
 
   SpacePacketReader spacePacket;
   spacePacket.setReadOnlyData(start, remainingSize);
+  if (DEBUG_MPSOC_COMMUNICATION) {
+    sif::debug << "RECV MPSOC packet. APID 0x" << std::hex << std::setw(3) << spacePacket.getApid()
+               << std::dec << " Size " << spacePacket.getFullPacketLen() << " SSC "
+               << spacePacket.getSequenceCount() << std::endl;
+  }
   if (spacePacket.isNull()) {
     return returnvalue::FAILED;
   }
@@ -467,7 +473,7 @@ void PlocMpsocHandler::setNormalDatapoolEntriesInvalid() {
   hkReport.setValidity(false, true);
 }
 
-uint32_t PlocMpsocHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 10000; }
+uint32_t PlocMpsocHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 15000; }
 
 ReturnValue_t PlocMpsocHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                         LocalDataPoolManager& poolManager) {
@@ -700,6 +706,13 @@ ReturnValue_t PlocMpsocHandler::finishTcPrep(mpsoc::TcBase& tcBase) {
   rawPacket = commandBuffer;
   rawPacketLen = tcBase.getFullPacketLen();
   sequenceCount++;
+
+  if (DEBUG_MPSOC_COMMUNICATION) {
+    sif::debug << "SEND MPSOC packet. APID 0x" << std::hex << std::setw(3) << tcBase.getApid()
+               << " Size " << std::dec << tcBase.getFullPacketLen() << " SSC "
+               << tcBase.getSeqCount() << std::endl;
+  }
+  cmdCountdown.resetTimer();
   return returnvalue::OK;
 }
 
@@ -1223,10 +1236,12 @@ void PlocMpsocHandler::dataReceived(ActionId_t actionId, const uint8_t* data, ui
 
 void PlocMpsocHandler::completionSuccessfulReceived(ActionId_t actionId) {
   if (actionId == supv::ACK_REPORT) {
-    sif::warning
-        << "PlocMpsocHandler::completionSuccessfulReceived: Only received ACK report. Consider "
-           "increasing the MPSoC boot timer."
-        << std::endl;
+    // I seriously don't know why this happens..
+    //    sif::warning
+    //        << "PlocMpsocHandler::completionSuccessfulReceived: Only received ACK report. Consider
+    //        "
+    //           "increasing the MPSoC boot timer."
+    //        << std::endl;
   } else if (actionId != supv::EXE_REPORT) {
     sif::warning << "PlocMpsocHandler::completionSuccessfulReceived: Did not expect the action "
                  << "ID " << actionId << std::endl;
@@ -1490,7 +1505,7 @@ LocalPoolDataSetBase* PlocMpsocHandler::getDataSetHandle(sid_t sid) {
 
 bool PlocMpsocHandler::dontCheckQueue() {
   // The TC and TMs need to be handled strictly sequentially, so while a command is pending,
-  // more specifically while replies are still expected, do not check the queue.s
+  // more specifically while replies are still expected, do not check the queue.
   return commandIsPending;
 }
 

linux/payload/PlocMpsocHandler.h

@@ -17,6 +17,8 @@
 #include "fsfw_hal/linux/gpio/Gpio.h"
 #include "fsfw_hal/linux/serial/SerialComIF.h"
 
+static constexpr bool DEBUG_MPSOC_COMMUNICATION = false;
+
 /**
  * @brief	This is the device handler for the MPSoC of the payload computer.
  *

mission/acs/SusHandler.cpp

@@ -97,7 +97,7 @@ ReturnValue_t SusHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8
   // appear sometimes for the SUS device: Allow invalid message up to a certain threshold
   // before triggering FDIR reactions.
   if (reply->tempRaw == 0xfff and not waitingForRecovery) {
-    if (invalidMsgCounter == 0) {
+    if (invalidMsgCounter == 0 and invalidMsgPeriodCounter == 0) {
       triggerEvent(TEMPERATURE_ALL_ONES_START);
     } else if (invalidMsgCounter == susMax1227::MAX_INVALID_MSG_COUNT) {
       triggerEvent(DeviceHandlerIF::DEVICE_WANTS_HARD_REBOOT);
@@ -110,8 +110,17 @@ ReturnValue_t SusHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8
     return returnvalue::OK;
   }
   if (invalidMsgCounter > 0) {
-    triggerEvent(TEMPERATURE_ALL_ONES_RECOVERY, invalidMsgCounter);
+    invalidMsgPeriodCounter++;
+    if (invalidMsgCounter > invalidMsgCounterMax) {
+      invalidMsgCounterMax = invalidMsgCounter;
+    }
     invalidMsgCounter = 0;
+    invalidMsgCountdown.resetTimer();
+  }
+  if (invalidMsgCountdown.hasTimedOut() and invalidMsgPeriodCounter > 0) {
+    triggerEvent(TEMPERATURE_ALL_ONES_RECOVERY, invalidMsgPeriodCounter, invalidMsgCounterMax);
+    invalidMsgPeriodCounter = 0;
+    invalidMsgCounterMax = 0;
   }
   dataset.setValidity(true, true);
   dataset.tempC = max1227::getTemperature(reply->tempRaw);

mission/acs/SusHandler.h

@@ -20,8 +20,9 @@ class SusHandler : public DeviceHandlerBase {
   //! [EXPORT] : [COMMENT] Detected invalid values, starting invalid message counting
   static constexpr Event TEMPERATURE_ALL_ONES_START =
       event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
-  //! [EXPORT] : [COMMENT] Detected valid values again, resetting invalid message counter.
-  //! P1: Invalid message counter.
+  //! [EXPORT] : [COMMENT] Detected valid values for a prolonged time again, resetting all counters.
+  //! P1: Number of periods with invalid messages.
+  //! P2: Maximum invalid message counter.
   static constexpr Event TEMPERATURE_ALL_ONES_RECOVERY =
       event::makeEvent(SUBSYSTEM_ID, 1, severity::INFO);
 
@@ -54,8 +55,13 @@ class SusHandler : public DeviceHandlerBase {
   susMax1227::SusDataset dataset;
   acs::SusRequest request{};
   uint8_t susIdx;
+
+  //  After 1 minute, trigger the event for the invalid messages.
+  Countdown invalidMsgCountdown = Countdown(60000);
   bool waitingForRecovery = true;
   uint32_t invalidMsgCounter = 0;
+  uint32_t invalidMsgCounterMax = 0;
+  uint32_t invalidMsgPeriodCounter = 0;
 
   uint32_t transitionDelay = 1000;
   bool goToNormalMode = false;

mission/acs/str/StarTrackerHandler.cpp

@@ -49,6 +49,13 @@ StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF,
       subscriptionSet(this),
       logSubscriptionSet(this),
       debugCameraSet(this),
+      autoBlobSet(this),
+      matchedCentroidsSet(this),
+      blobSet(this),
+      blobsSet(this),
+      centroidSet(this),
+      centroidsSet(this),
+      contrastSet(this),
       strHelper(strHelper),
       paramJsonFile(jsonFileStr),
       powerSwitch(powerSwitch) {
@@ -59,6 +66,8 @@ StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF,
     sif::error << "StarTrackerHandler: Invalid str image loader" << std::endl;
   }
   eventQueue = QueueFactory::instance()->createMessageQueue(EventMessage::EVENT_MESSAGE_SIZE * 5);
+  additionalRequestedTm.emplace(startracker::REQ_TEMPERATURE);
+  currentSecondaryTmIter = additionalRequestedTm.begin();
 }
 
 StarTrackerHandler::~StarTrackerHandler() {}
@@ -165,6 +174,35 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
   ReturnValue_t result = returnvalue::OK;
 
   switch (actionId) {
+    case (startracker::ADD_SECONDARY_TM_TO_NORMAL_MODE): {
+      if (size < 4) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      DeviceCommandId_t idToAdd;
+      result =
+          SerializeAdapter::deSerialize(&idToAdd, data, &size, SerializeIF::Endianness::NETWORK);
+      if (result != returnvalue::OK) {
+        return result;
+      }
+      addSecondaryTmForNormalMode(idToAdd);
+      return EXECUTION_FINISHED;
+    }
+    case (startracker::RESET_SECONDARY_TM_SET): {
+      resetSecondaryTmSet();
+      return EXECUTION_FINISHED;
+    }
+    case (startracker::READ_SECONDARY_TM_SET): {
+      std::vector<uint8_t> dataVec(additionalRequestedTm.size() * 4);
+      unsigned idx = 0;
+      size_t serLen = 0;
+      for (const auto& cmd : additionalRequestedTm) {
+        SerializeAdapter::serialize(&cmd, dataVec.data() + idx * 4, &serLen, dataVec.size(),
+                                    SerializeIF::Endianness::NETWORK);
+        idx++;
+      }
+      actionHelper.reportData(commandedBy, actionId, dataVec.data(), dataVec.size());
+      return EXECUTION_FINISHED;
+    }
     case (startracker::STOP_IMAGE_LOADER): {
       strHelper->stopProcess();
       return EXECUTION_FINISHED;
@@ -306,13 +344,20 @@ ReturnValue_t StarTrackerHandler::buildNormalDeviceCommand(DeviceCommandId_t* id
     return NOTHING_TO_SEND;
   }
   switch (normalState) {
-    case NormalState::TEMPERATURE_REQUEST:
-      *id = startracker::REQ_TEMPERATURE;
+    case NormalState::SECONDARY_REQUEST:
+      if (additionalRequestedTm.size() == 0) {
+        break;
+      }
+      *id = *currentSecondaryTmIter;
+      currentSecondaryTmIter++;
+      if (currentSecondaryTmIter == additionalRequestedTm.end()) {
+        currentSecondaryTmIter = additionalRequestedTm.begin();
+      }
       normalState = NormalState::SOLUTION_REQUEST;
       break;
     case NormalState::SOLUTION_REQUEST:
       *id = startracker::REQ_SOLUTION;
-      normalState = NormalState::TEMPERATURE_REQUEST;
+      normalState = NormalState::SECONDARY_REQUEST;
       break;
     default:
       sif::debug << "StarTrackerHandler::buildNormalDeviceCommand: Invalid normal step"
@@ -472,6 +517,18 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
       prepareTimeRequest();
       return returnvalue::OK;
     }
+    case (startracker::REQ_CENTROID): {
+      prepareRequestCentroidTm();
+      return returnvalue::OK;
+    }
+    case (startracker::REQ_CENTROIDS): {
+      prepareRequestCentroidsTm();
+      return returnvalue::OK;
+    }
+    case (startracker::REQ_CONTRAST): {
+      prepareRequestContrastTm();
+      return returnvalue::OK;
+    }
     case (startracker::BOOT): {
       prepareBootCommand();
       return returnvalue::OK;
@@ -607,6 +664,22 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
       result = prepareRequestLisaParams();
       return result;
     }
+    case (startracker::REQ_MATCHED_CENTROIDS): {
+      result = prepareRequestMatchedCentroidsTm();
+      return result;
+    }
+    case (startracker::REQ_BLOB): {
+      result = prepareRequestBlobTm();
+      return result;
+    }
+    case (startracker::REQ_BLOBS): {
+      result = prepareRequestBlobsTm();
+      return result;
+    }
+    case (startracker::REQ_AUTO_BLOB): {
+      result = prepareRequestAutoBlobTm();
+      return returnvalue::OK;
+    }
     case (startracker::REQ_MATCHING): {
       result = prepareRequestMatchingParams();
       return result;
@@ -729,6 +802,20 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
   this->insertInCommandAndReplyMap(startracker::REQ_DEBUG_CAMERA, 3, &debugCameraSet,
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
+  this->insertInCommandAndReplyMap(startracker::REQ_AUTO_BLOB, 3, &autoBlobSet,
+                                   startracker::MAX_FRAME_SIZE * 2 + 2);
+  this->insertInCommandAndReplyMap(startracker::REQ_MATCHED_CENTROIDS, 3, &matchedCentroidsSet,
+                                   startracker::MAX_FRAME_SIZE * 2 + 2);
+  this->insertInCommandAndReplyMap(startracker::REQ_BLOB, 3, &blobSet,
+                                   startracker::MAX_FRAME_SIZE * 2 + 2);
+  this->insertInCommandAndReplyMap(startracker::REQ_BLOBS, 3, &blobsSet,
+                                   startracker::MAX_FRAME_SIZE * 2 + 2);
+  this->insertInCommandAndReplyMap(startracker::REQ_CENTROID, 3, &centroidSet,
+                                   startracker::MAX_FRAME_SIZE * 2 + 2);
+  this->insertInCommandAndReplyMap(startracker::REQ_CENTROIDS, 3, &centroidsSet,
+                                   startracker::MAX_FRAME_SIZE * 2 + 2);
+  this->insertInCommandAndReplyMap(startracker::REQ_CONTRAST, 3, &contrastSet,
+                                   startracker::MAX_FRAME_SIZE * 2 + 2);
 }
 
 ReturnValue_t StarTrackerHandler::isModeCombinationValid(Mode_t mode, Submode_t submode) {
@@ -860,6 +947,74 @@ void StarTrackerHandler::setUpJsonCfgs(JsonConfigs& cfgs, const char* paramJsonF
   JCFG_DONE = true;
 }
 
+ReturnValue_t StarTrackerHandler::statusFieldCheck(const uint8_t* rawFrame) {
+  uint8_t status = startracker::getStatusField(rawFrame);
+  if (status != startracker::STATUS_OK) {
+    sif::warning << "StarTrackerHandler::handleTm: Reply error: "
+                 << static_cast<unsigned int>(status) << std::endl;
+    return REPLY_ERROR;
+  }
+  return returnvalue::OK;
+}
+
+void StarTrackerHandler::addSecondaryTmForNormalMode(DeviceCommandId_t cmd) {
+  additionalRequestedTm.emplace(cmd);
+}
+
+void StarTrackerHandler::resetSecondaryTmSet() {
+  additionalRequestedTm.clear();
+  additionalRequestedTm.emplace(startracker::REQ_TEMPERATURE);
+  currentSecondaryTmIter = additionalRequestedTm.begin();
+  {
+    PoolReadGuard pg(&autoBlobSet);
+    if (pg.getReadResult() == returnvalue::OK) {
+      autoBlobSet.setValidity(false, true);
+    }
+  }
+  {
+    PoolReadGuard pg(&matchedCentroidsSet);
+    if (pg.getReadResult() == returnvalue::OK) {
+      matchedCentroidsSet.setValidity(false, true);
+    }
+  }
+  {
+    PoolReadGuard pg(&blobSet);
+    if (pg.getReadResult() == returnvalue::OK) {
+      blobSet.setValidity(false, true);
+    }
+  }
+  {
+    PoolReadGuard pg(&blobsSet);
+    if (pg.getReadResult() == returnvalue::OK) {
+      blobsSet.setValidity(false, true);
+    }
+  }
+  {
+    PoolReadGuard pg(&centroidSet);
+    if (pg.getReadResult() == returnvalue::OK) {
+      centroidSet.setValidity(false, true);
+    }
+  }
+  {
+    PoolReadGuard pg(&contrastSet);
+    if (pg.getReadResult() == returnvalue::OK) {
+      contrastSet.setValidity(false, true);
+    }
+  }
+  {
+    PoolReadGuard pg(&centroidsSet);
+    if (pg.getReadResult() == returnvalue::OK) {
+      centroidsSet.setValidity(false, true);
+    }
+  }
+  {
+    PoolReadGuard pg(&histogramSet);
+    if (pg.getReadResult() == returnvalue::OK) {
+      histogramSet.setValidity(false, true);
+    }
+  }
+}
+
 void StarTrackerHandler::bootBootloader() {
   if (internalState == InternalState::IDLE) {
     internalState = InternalState::BOOT_BOOTLOADER;
@@ -896,24 +1051,24 @@ ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t* start, size_t rema
     }
     case TMTC_ACTIONREPLY: {
       *foundLen = remainingSize;
+      fullPacketLen = remainingSize;
       return scanForActionReply(startracker::getId(start), foundId);
-      break;
     }
     case TMTC_SETPARAMREPLY: {
       *foundLen = remainingSize;
+      fullPacketLen = remainingSize;
       return scanForSetParameterReply(startracker::getId(start), foundId);
-      break;
     }
     case TMTC_PARAMREPLY: {
       *foundLen = remainingSize;
+      fullPacketLen = remainingSize;
       return scanForGetParameterReply(startracker::getId(start), foundId);
-      break;
     }
     case TMTC_TELEMETRYREPLYA:
     case TMTC_TELEMETRYREPLY: {
       *foundLen = remainingSize;
+      fullPacketLen = remainingSize;
       return scanForTmReply(startracker::getId(start), foundId);
-      break;
     }
     default: {
       sif::debug << "StarTrackerHandler::scanForReply: Reply has invalid type id" << std::endl;
@@ -933,7 +1088,7 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
       break;
     }
     case (startracker::REQ_TIME): {
-      result = handleTm(packet, timeSet, startracker::TimeSet::SIZE, "REQ_TIME");
+      result = handleTm(packet, timeSet, "REQ_TIME");
       break;
     }
     case (startracker::PING_REQUEST): {
@@ -948,7 +1103,7 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
       break;
     }
     case (startracker::REQ_VERSION): {
-      result = handleTm(packet, versionSet, startracker::VersionSet::SIZE, "REQ_VERSION");
+      result = handleTm(packet, versionSet, "REQ_VERSION");
       if (result != returnvalue::OK) {
         return result;
       }
@@ -959,23 +1114,51 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
       break;
     }
     case (startracker::REQ_INTERFACE): {
-      result = handleTm(packet, interfaceSet, startracker::InterfaceSet::SIZE, "REQ_INTERFACE");
+      result = handleTm(packet, interfaceSet, "REQ_INTERFACE");
       break;
     }
     case (startracker::REQ_POWER): {
-      result = handleTm(packet, powerSet, startracker::PowerSet::SIZE, "REQ_POWER");
+      result = handleTm(packet, powerSet, "REQ_POWER");
       break;
     }
     case (startracker::REQ_SOLUTION): {
-      result = handleTm(packet, solutionSet, startracker::SolutionSet::SIZE, "REQ_SOLUTION");
+      result = handleTm(packet, solutionSet, "REQ_SOLUTION");
+      break;
+    }
+    case (startracker::REQ_CONTRAST): {
+      result = handleTm(packet, contrastSet, "REQ_CONTRAST");
+      break;
+    }
+    case (startracker::REQ_AUTO_BLOB): {
+      result = handleAutoBlobTm(packet);
+      break;
+    }
+    case (startracker::REQ_MATCHED_CENTROIDS): {
+      result = handleMatchedCentroidTm(packet);
+      break;
+    }
+    case (startracker::REQ_BLOB): {
+      result = handleBlobTm(packet);
+      break;
+    }
+    case (startracker::REQ_BLOBS): {
+      result = handleBlobsTm(packet);
+      break;
+    }
+    case (startracker::REQ_CENTROID): {
+      result = handleCentroidTm(packet);
+      break;
+    }
+    case (startracker::REQ_CENTROIDS): {
+      result = handleCentroidsTm(packet);
       break;
     }
     case (startracker::REQ_TEMPERATURE): {
-      result = handleTm(packet, temperatureSet, startracker::TemperatureSet::SIZE, "REQ_TEMP");
+      result = handleTm(packet, temperatureSet, "REQ_TEMP");
       break;
     }
     case (startracker::REQ_HISTOGRAM): {
-      result = handleTm(packet, histogramSet, startracker::HistogramSet::SIZE, "REQ_HISTO");
+      result = handleTm(packet, histogramSet, "REQ_HISTO");
       break;
     }
     case (startracker::SUBSCRIPTION):
@@ -1329,6 +1512,56 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
 
   localDataPoolMap.emplace(startracker::CHKSUM, new PoolEntry<uint32_t>({0}));
 
+  localDataPoolMap.emplace(startracker::TICKS_AUTO_BLOB, new PoolEntry<uint32_t>());
+  localDataPoolMap.emplace(startracker::TIME_AUTO_BLOB, new PoolEntry<uint64_t>());
+  localDataPoolMap.emplace(startracker::AUTO_BLOB_THRESHOLD, new PoolEntry<float>());
+
+  localDataPoolMap.emplace(startracker::PoolIds::NUM_MATCHED_CENTROIDS, new PoolEntry<uint8_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::MATCHED_CENTROIDS_STAR_IDS,
+                           new PoolEntry<uint32_t>(16));
+  localDataPoolMap.emplace(startracker::PoolIds::MATCHED_CENTROIDS_X_COORDS,
+                           new PoolEntry<float>(16));
+  localDataPoolMap.emplace(startracker::PoolIds::MATCHED_CENTROIDS_Y_COORDS,
+                           new PoolEntry<float>(16));
+  localDataPoolMap.emplace(startracker::PoolIds::MATCHED_CENTROIDS_X_ERRORS,
+                           new PoolEntry<float>(16));
+  localDataPoolMap.emplace(startracker::PoolIds::MATCHED_CENTROIDS_Y_ERRORS,
+                           new PoolEntry<float>(16));
+  localDataPoolMap.emplace(startracker::PoolIds::TICKS_MATCHED_CENTROIDS,
+                           new PoolEntry<uint32_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::TIME_MATCHED_CENTROIDS, new PoolEntry<uint64_t>());
+
+  localDataPoolMap.emplace(startracker::PoolIds::BLOB_TICKS, new PoolEntry<uint32_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::BLOB_TIME, new PoolEntry<uint64_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::BLOB_COUNT, new PoolEntry<uint32_t>());
+
+  localDataPoolMap.emplace(startracker::PoolIds::BLOBS_TICKS, new PoolEntry<uint32_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::BLOBS_TIME, new PoolEntry<uint64_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::BLOBS_COUNT, new PoolEntry<uint16_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::BLOBS_COUNT_USED, new PoolEntry<uint16_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::BLOBS_NR_4LINES_SKIPPED,
+                           new PoolEntry<uint16_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::BLOBS_X_COORDS, new PoolEntry<uint16_t>(8));
+  localDataPoolMap.emplace(startracker::PoolIds::BLOBS_Y_COORDS, new PoolEntry<uint16_t>(8));
+
+  localDataPoolMap.emplace(startracker::PoolIds::CENTROID_TICKS, new PoolEntry<uint32_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::CENTROID_TIME, new PoolEntry<uint64_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::CENTROID_COUNT, new PoolEntry<uint32_t>());
+
+  localDataPoolMap.emplace(startracker::PoolIds::CENTROIDS_TICKS, new PoolEntry<uint32_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::CENTROIDS_TIME, new PoolEntry<uint64_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::CENTROIDS_COUNT, new PoolEntry<uint16_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::CENTROIDS_X_COORDS, new PoolEntry<float>(16));
+  localDataPoolMap.emplace(startracker::PoolIds::CENTROIDS_Y_COORDS, new PoolEntry<float>(16));
+  localDataPoolMap.emplace(startracker::PoolIds::CENTROIDS_MAGNITUDES, new PoolEntry<uint8_t>(16));
+
+  localDataPoolMap.emplace(startracker::PoolIds::CONTRAST_TICKS, new PoolEntry<uint32_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::CONTRAST_TIME, new PoolEntry<uint64_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::CONTRAST_A, new PoolEntry<uint32_t>(9));
+  localDataPoolMap.emplace(startracker::PoolIds::CONTRAST_B, new PoolEntry<uint32_t>(9));
+  localDataPoolMap.emplace(startracker::PoolIds::CONTRAST_C, new PoolEntry<uint32_t>(9));
+  localDataPoolMap.emplace(startracker::PoolIds::CONTRAST_D, new PoolEntry<uint32_t>(9));
+
   poolManager.subscribeForDiagPeriodicPacket(
       subdp::DiagnosticsHkPeriodicParams(temperatureSet.getSid(), false, 10.0));
   poolManager.subscribeForRegularPeriodicPacket(
@@ -1343,6 +1576,20 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
       subdp::RegularHkPeriodicParams(histogramSet.getSid(), false, 10.0));
   poolManager.subscribeForRegularPeriodicPacket(
       subdp::RegularHkPeriodicParams(lisaSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(autoBlobSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(matchedCentroidsSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(blobSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(blobsSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(centroidSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(centroidsSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(contrastSet.getSid(), false, 10.0));
   return returnvalue::OK;
 }
 
@@ -1584,8 +1831,36 @@ ReturnValue_t StarTrackerHandler::scanForTmReply(uint8_t replyId, DeviceCommandI
       *foundId = startracker::REQ_SOLUTION;
       break;
     }
+    case (startracker::ID::BLOB): {
+      *foundId = startracker::REQ_BLOB;
+      break;
+    }
+    case (startracker::ID::BLOBS): {
+      *foundId = startracker::REQ_BLOBS;
+      break;
+    }
+    case (startracker::ID::CENTROID): {
+      *foundId = startracker::REQ_CENTROID;
+      break;
+    }
+    case (startracker::ID::CENTROIDS): {
+      *foundId = startracker::REQ_CENTROIDS;
+      break;
+    }
+    case (startracker::ID::AUTO_BLOB): {
+      *foundId = startracker::REQ_AUTO_BLOB;
+      break;
+    }
+    case (startracker::ID::MATCHED_CENTROIDS): {
+      *foundId = startracker::REQ_MATCHED_CENTROIDS;
+      break;
+    }
+    case (startracker::ID::CONTRAST): {
+      *foundId = startracker::REQ_CONTRAST;
+      break;
+    }
     default: {
-      sif::debug << "StarTrackerHandler::scanForTmReply: Reply contains invalid reply id: "
+      sif::debug << "StarTrackerHandler::scanForTmReply: Reply contains invalid reply ID: "
                  << static_cast<unsigned int>(replyId) << std::endl;
       return returnvalue::FAILED;
       break;
@@ -1760,6 +2035,62 @@ void StarTrackerHandler::prepareHistogramRequest() {
   rawPacketLen = length;
 }
 
+ReturnValue_t StarTrackerHandler::prepareRequestAutoBlobTm() {
+  uint32_t length = 0;
+  arc_tm_pack_autoblob_req(commandBuffer, &length);
+  rawPacket = commandBuffer;
+  rawPacketLen = length;
+  return returnvalue::OK;
+}
+
+ReturnValue_t StarTrackerHandler::prepareRequestMatchedCentroidsTm() {
+  uint32_t length = 0;
+  arc_tm_pack_matchedcentroids_req(commandBuffer, &length);
+  rawPacket = commandBuffer;
+  rawPacketLen = length;
+  return returnvalue::OK;
+}
+
+ReturnValue_t StarTrackerHandler::prepareRequestBlobTm() {
+  uint32_t length = 0;
+  arc_tm_pack_blob_req(commandBuffer, &length);
+  rawPacket = commandBuffer;
+  rawPacketLen = length;
+  return returnvalue::OK;
+}
+
+ReturnValue_t StarTrackerHandler::prepareRequestBlobsTm() {
+  uint32_t length = 0;
+  arc_tm_pack_blobs_req(commandBuffer, &length);
+  rawPacket = commandBuffer;
+  rawPacketLen = length;
+  return returnvalue::OK;
+}
+
+ReturnValue_t StarTrackerHandler::prepareRequestCentroidTm() {
+  uint32_t length = 0;
+  arc_tm_pack_centroid_req(commandBuffer, &length);
+  rawPacket = commandBuffer;
+  rawPacketLen = length;
+  return returnvalue::OK;
+}
+
+ReturnValue_t StarTrackerHandler::prepareRequestCentroidsTm() {
+  uint32_t length = 0;
+  arc_tm_pack_centroids_req(commandBuffer, &length);
+  rawPacket = commandBuffer;
+  rawPacketLen = length;
+  return returnvalue::OK;
+}
+
+ReturnValue_t StarTrackerHandler::prepareRequestContrastTm() {
+  uint32_t length = 0;
+  arc_tm_pack_contrast_req(commandBuffer, &length);
+  rawPacket = commandBuffer;
+  rawPacketLen = length;
+  return returnvalue::OK;
+}
+
 ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData,
                                                       size_t commandDataLen,
                                                       ArcsecJsonParamBase& paramSet,
@@ -2038,13 +2369,10 @@ ReturnValue_t StarTrackerHandler::checkProgram() {
 }
 
 ReturnValue_t StarTrackerHandler::handleTm(const uint8_t* rawFrame, LocalPoolDataSetBase& dataset,
-                                           size_t size, const char* context) {
-  ReturnValue_t result = returnvalue::OK;
-  uint8_t status = startracker::getStatusField(rawFrame);
-  if (status != startracker::STATUS_OK) {
-    sif::warning << "StarTrackerHandler::handleTm: Reply error: "
-                 << static_cast<unsigned int>(status) << std::endl;
-    return REPLY_ERROR;
+                                           const char* context) {
+  ReturnValue_t result = statusFieldCheck(rawFrame);
+  if (result != returnvalue::OK) {
+    return result;
   }
   result = dataset.read(TIMEOUT_TYPE, MUTEX_TIMEOUT);
   if (result != returnvalue::OK) {
@@ -2052,10 +2380,11 @@ ReturnValue_t StarTrackerHandler::handleTm(const uint8_t* rawFrame, LocalPoolDat
   }
   const uint8_t* reply = rawFrame + TICKS_OFFSET;
   dataset.setValidityBufferGeneration(false);
-  result = dataset.deSerialize(&reply, &size, SerializeIF::Endianness::LITTLE);
+  size_t sizeLeft = fullPacketLen;
+  result = dataset.deSerialize(&reply, &sizeLeft, SerializeIF::Endianness::LITTLE);
   if (result != returnvalue::OK) {
-    sif::warning << "StarTrackerHandler::handleTm: Deserialization failed for " << context
-                 << std::endl;
+    sif::warning << "StarTrackerHandler::handleTm: Deserialization failed for " << context << ": 0x"
+                 << std::hex << std::setw(4) << result << std::dec << std::endl;
   }
   dataset.setValidityBufferGeneration(true);
   dataset.setValidity(true, true);
@@ -2069,6 +2398,262 @@ ReturnValue_t StarTrackerHandler::handleTm(const uint8_t* rawFrame, LocalPoolDat
   return result;
 }
 
+ReturnValue_t StarTrackerHandler::handleAutoBlobTm(const uint8_t* rawFrame) {
+  ReturnValue_t result = statusFieldCheck(rawFrame);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  rawFrame += TICKS_OFFSET;
+  size_t remainingLen = fullPacketLen;
+  PoolReadGuard pg(&autoBlobSet);
+  result = pg.getReadResult();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&autoBlobSet.ticks, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&autoBlobSet.timeUs, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&autoBlobSet.threshold, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  autoBlobSet.setValidity(true, true);
+  return returnvalue::OK;
+}
+
+ReturnValue_t StarTrackerHandler::handleMatchedCentroidTm(const uint8_t* rawFrame) {
+  ReturnValue_t result = statusFieldCheck(rawFrame);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  rawFrame += TICKS_OFFSET;
+  size_t remainingLen = fullPacketLen;
+  PoolReadGuard pg(&matchedCentroidsSet);
+  result = pg.getReadResult();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&matchedCentroidsSet.ticks, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&matchedCentroidsSet.timeUs, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&matchedCentroidsSet.numberOfMatchedCentroids, &rawFrame,
+                                         &remainingLen, SerializeIF::Endianness::LITTLE);
+
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  // Yeah, we serialize it like that because I can't model anything with that local datapool crap.
+  for (unsigned idx = 0; idx < 16; idx++) {
+    result = SerializeAdapter::deSerialize(&matchedCentroidsSet.starIds[idx], &rawFrame,
+                                           &remainingLen, SerializeIF::Endianness::LITTLE);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = SerializeAdapter::deSerialize(&matchedCentroidsSet.xCoords[idx], &rawFrame,
+                                           &remainingLen, SerializeIF::Endianness::LITTLE);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = SerializeAdapter::deSerialize(&matchedCentroidsSet.yCoords[idx], &rawFrame,
+                                           &remainingLen, SerializeIF::Endianness::LITTLE);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = SerializeAdapter::deSerialize(&matchedCentroidsSet.xErrors[idx], &rawFrame,
+                                           &remainingLen, SerializeIF::Endianness::LITTLE);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = SerializeAdapter::deSerialize(&matchedCentroidsSet.yErrors[idx], &rawFrame,
+                                           &remainingLen, SerializeIF::Endianness::LITTLE);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+  }
+  matchedCentroidsSet.setValidity(true, true);
+  return returnvalue::OK;
+}
+
+ReturnValue_t StarTrackerHandler::handleBlobTm(const uint8_t* rawFrame) {
+  ReturnValue_t result = statusFieldCheck(rawFrame);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  rawFrame += TICKS_OFFSET;
+  size_t remainingLen = fullPacketLen;
+  PoolReadGuard pg(&blobsSet);
+  result = pg.getReadResult();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&blobSet.ticks, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&blobSet.timeUs, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&blobSet.blobCount, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  blobSet.setValidity(true, true);
+  return returnvalue::OK;
+}
+
+ReturnValue_t StarTrackerHandler::handleBlobsTm(const uint8_t* rawFrame) {
+  ReturnValue_t result = statusFieldCheck(rawFrame);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  rawFrame += TICKS_OFFSET;
+  size_t remainingLen = fullPacketLen;
+  PoolReadGuard pg(&blobsSet);
+  result = pg.getReadResult();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&blobsSet.ticks, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&blobsSet.timeUs, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&blobsSet.blobsCount, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&blobsSet.blobsCountUsed, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&blobsSet.nr4LinesSkipped, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  for (unsigned idx = 0; idx < 8; idx++) {
+    result = SerializeAdapter::deSerialize(&blobsSet.xCoords[idx], &rawFrame, &remainingLen,
+                                           SerializeIF::Endianness::LITTLE);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = SerializeAdapter::deSerialize(&blobsSet.yCoords[idx], &rawFrame, &remainingLen,
+                                           SerializeIF::Endianness::LITTLE);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+  }
+  blobsSet.setValidity(true, true);
+  return returnvalue::OK;
+}
+
+ReturnValue_t StarTrackerHandler::handleCentroidTm(const uint8_t* rawFrame) {
+  ReturnValue_t result = statusFieldCheck(rawFrame);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  rawFrame += TICKS_OFFSET;
+  size_t remainingLen = fullPacketLen;
+  PoolReadGuard pg(&centroidsSet);
+  result = pg.getReadResult();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  result = SerializeAdapter::deSerialize(&centroidSet.ticks, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&centroidSet.timeUs, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&centroidSet.centroidCount, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  centroidSet.setValidity(true, true);
+  return returnvalue::OK;
+}
+
+ReturnValue_t StarTrackerHandler::handleCentroidsTm(const uint8_t* rawFrame) {
+  ReturnValue_t result = statusFieldCheck(rawFrame);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  rawFrame += TICKS_OFFSET;
+  size_t remainingLen = fullPacketLen;
+  PoolReadGuard pg(&centroidsSet);
+  result = pg.getReadResult();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  result = SerializeAdapter::deSerialize(&centroidsSet.ticksCentroidsTm, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&centroidsSet.timeUsCentroidsTm, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = SerializeAdapter::deSerialize(&centroidsSet.centroidsCount, &rawFrame, &remainingLen,
+                                         SerializeIF::Endianness::LITTLE);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  for (unsigned idx = 0; idx < 16; idx++) {
+    result = SerializeAdapter::deSerialize(&centroidsSet.centroidsXCoords[idx], &rawFrame,
+                                           &remainingLen, SerializeIF::Endianness::LITTLE);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = SerializeAdapter::deSerialize(&centroidsSet.centroidsYCoords[idx], &rawFrame,
+                                           &remainingLen, SerializeIF::Endianness::LITTLE);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = SerializeAdapter::deSerialize(&centroidsSet.centroidsMagnitudes[idx], &rawFrame,
+                                           &remainingLen, SerializeIF::Endianness::LITTLE);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+  }
+  centroidsSet.setValidity(true, true);
+  return returnvalue::OK;
+}
+
 ReturnValue_t StarTrackerHandler::handleActionReplySet(const uint8_t* rawFrame,
                                                        LocalPoolDataSetBase& dataset, size_t size) {
   ReturnValue_t result = returnvalue::OK;
@@ -2204,10 +2789,17 @@ ReturnValue_t StarTrackerHandler::checkCommand(ActionId_t actionId) {
     case startracker::REQ_SUBSCRIPTION:
     case startracker::REQ_LOG_SUBSCRIPTION:
     case startracker::REQ_DEBUG_CAMERA:
+    case startracker::REQ_MATCHED_CENTROIDS:
+    case startracker::REQ_BLOB:
+    case startracker::REQ_BLOBS:
+    case startracker::REQ_CENTROID:
+    case startracker::REQ_CENTROIDS:
+    case startracker::REQ_CONTRAST: {
       if (getMode() == MODE_ON and getSubmode() != startracker::Program::FIRMWARE) {
         return STARTRACKER_NOT_RUNNING_FIRMWARE;
       }
       break;
+    }
     case startracker::FIRMWARE_UPDATE:
     case startracker::FLASH_READ:
       if (getMode() != MODE_ON or getSubmode() != startracker::Program::BOOTLOADER) {

mission/acs/str/StarTrackerHandler.h

@@ -8,6 +8,7 @@
 #include <mission/acs/str/strJsonCommands.h>
 #include <thirdparty/sagittactl/wire/common/genericstructs.h>
 
+#include <set>
 #include <thread>
 
 #include "OBSWConfig.h"
@@ -151,6 +152,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
   static const uint8_t PARAMS_OFFSET = 2;
   static const uint8_t TICKS_OFFSET = 3;
   static const uint8_t TIME_OFFSET = 7;
+  static const uint8_t TM_PARAM_OFFSET = 15;
   static const uint8_t PARAMETER_ID_OFFSET = 1;
   static const uint8_t ACTION_ID_OFFSET = 1;
   static const uint8_t ACTION_DATA_OFFSET = 3;
@@ -204,6 +206,13 @@ class StarTrackerHandler : public DeviceHandlerBase {
   startracker::SubscriptionSet subscriptionSet;
   startracker::LogSubscriptionSet logSubscriptionSet;
   startracker::DebugCameraSet debugCameraSet;
+  startracker::AutoBlobSet autoBlobSet;
+  startracker::MatchedCentroidsSet matchedCentroidsSet;
+  startracker::BlobSet blobSet;
+  startracker::BlobsSet blobsSet;
+  startracker::CentroidSet centroidSet;
+  startracker::CentroidsSet centroidsSet;
+  startracker::ContrastSet contrastSet;
 
   // Pointer to object responsible for uploading and downloading images to/from the star tracker
   StrComHandler* strHelper = nullptr;
@@ -239,9 +248,9 @@ class StarTrackerHandler : public DeviceHandlerBase {
 
   std::string paramJsonFile;
 
-  enum class NormalState { TEMPERATURE_REQUEST, SOLUTION_REQUEST };
+  enum class NormalState { SECONDARY_REQUEST, SOLUTION_REQUEST };
 
-  NormalState normalState = NormalState::TEMPERATURE_REQUEST;
+  NormalState normalState = NormalState::SECONDARY_REQUEST;
 
   enum class StartupState {
     IDLE,
@@ -297,6 +306,11 @@ class StarTrackerHandler : public DeviceHandlerBase {
 
   const power::Switch_t powerSwitch = power::NO_SWITCH;
 
+  size_t fullPacketLen = 0;
+
+  std::set<DeviceCommandId_t> additionalRequestedTm{};
+  std::set<DeviceCommandId_t>::iterator currentSecondaryTmIter;
+
   /**
    * @brief   Handles internal state
    */
@@ -345,6 +359,18 @@ class StarTrackerHandler : public DeviceHandlerBase {
    */
   ReturnValue_t executeFlashReadCommand(const uint8_t* commandData, size_t commandDataLen);
 
+  /**
+   * Add a TM request to the list of telemetry which will be polled in the secondary step of
+   * the device communication.
+   * @param cmd
+   */
+  void addSecondaryTmForNormalMode(DeviceCommandId_t cmd);
+
+  /**
+   * Reset the secondary set, which will only contain a TEMPERATURE set request after the reset.
+   */
+  void resetSecondaryTmSet();
+
   /**
    * @brief   Fills command buffer with data to boot image (works only when star tracker is
    *          in bootloader mode).
@@ -429,6 +455,13 @@ class StarTrackerHandler : public DeviceHandlerBase {
   ReturnValue_t prepareRequestCentroidingParams();
   ReturnValue_t prepareRequestLisaParams();
   ReturnValue_t prepareRequestMatchingParams();
+  ReturnValue_t prepareRequestAutoBlobTm();
+  ReturnValue_t prepareRequestMatchedCentroidsTm();
+  ReturnValue_t prepareRequestBlobTm();
+  ReturnValue_t prepareRequestBlobsTm();
+  ReturnValue_t prepareRequestCentroidTm();
+  ReturnValue_t prepareRequestCentroidsTm();
+  ReturnValue_t prepareRequestContrastTm();
   ReturnValue_t prepareRequestTrackingParams();
   ReturnValue_t prepareRequestValidationParams();
   ReturnValue_t prepareRequestAlgoParams();
@@ -477,6 +510,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
    */
   void handleStartup(uint8_t tmType, uint8_t parameterId);
 
+  ReturnValue_t statusFieldCheck(const uint8_t* rawFrame);
   /**
    * @brief   Handles telemtry replies and fills the appropriate dataset
    *
@@ -485,9 +519,16 @@ class StarTrackerHandler : public DeviceHandlerBase {
    *
    * @return  returnvalue::OK if successful, otherwise error return value
    */
-  ReturnValue_t handleTm(const uint8_t* rawFrame, LocalPoolDataSetBase& dataset, size_t size,
+  ReturnValue_t handleTm(const uint8_t* rawFrame, LocalPoolDataSetBase& dataset,
                          const char* context);
 
+  ReturnValue_t handleAutoBlobTm(const uint8_t* rawFrame);
+  ReturnValue_t handleMatchedCentroidTm(const uint8_t* rawFrame);
+  ReturnValue_t handleBlobTm(const uint8_t* rawFrame);
+  ReturnValue_t handleBlobsTm(const uint8_t* rawFrame);
+  ReturnValue_t handleCentroidTm(const uint8_t* rawFrame);
+  ReturnValue_t handleCentroidsTm(const uint8_t* rawFrame);
+
   /**
    * @brief Checks if star tracker is in valid mode for executing the received command.
    *

mission/acs/str/strHelpers.h

@@ -272,7 +272,50 @@ enum PoolIds : lp_id_t {
   LOG_SUBSCRIPTION_LEVEL2,
   LOG_SUBSCRIPTION_MODULE2,
   DEBUG_CAMERA_TIMING,
-  DEBUG_CAMERA_TEST
+  DEBUG_CAMERA_TEST,
+
+  TICKS_AUTO_BLOB,
+  TIME_AUTO_BLOB,
+  AUTO_BLOB_THRESHOLD,
+
+  TICKS_MATCHED_CENTROIDS,
+  TIME_MATCHED_CENTROIDS,
+  NUM_MATCHED_CENTROIDS,
+  MATCHED_CENTROIDS_STAR_IDS,
+  MATCHED_CENTROIDS_X_COORDS,
+  MATCHED_CENTROIDS_Y_COORDS,
+  MATCHED_CENTROIDS_X_ERRORS,
+  MATCHED_CENTROIDS_Y_ERRORS,
+
+  BLOB_TICKS,
+  BLOB_TIME,
+  BLOB_COUNT,
+
+  BLOBS_TICKS,
+  BLOBS_TIME,
+  BLOBS_COUNT,
+  BLOBS_COUNT_USED,
+  BLOBS_NR_4LINES_SKIPPED,
+  BLOBS_X_COORDS,
+  BLOBS_Y_COORDS,
+
+  CENTROID_TICKS,
+  CENTROID_TIME,
+  CENTROID_COUNT,
+
+  CENTROIDS_TICKS,
+  CENTROIDS_TIME,
+  CENTROIDS_COUNT,
+  CENTROIDS_X_COORDS,
+  CENTROIDS_Y_COORDS,
+  CENTROIDS_MAGNITUDES,
+
+  CONTRAST_TICKS,
+  CONTRAST_TIME,
+  CONTRAST_A,
+  CONTRAST_B,
+  CONTRAST_C,
+  CONTRAST_D,
 };
 
 static const DeviceCommandId_t PING_REQUEST = 0;
@@ -291,6 +334,7 @@ static const DeviceCommandId_t IMAGE_PROCESSOR = 19;
 static const DeviceCommandId_t REQ_SOLUTION = 24;
 static const DeviceCommandId_t REQ_TEMPERATURE = 25;
 static const DeviceCommandId_t REQ_HISTOGRAM = 28;
+static constexpr DeviceCommandId_t REQ_CONTRAST = 29;
 static const DeviceCommandId_t LIMITS = 40;
 static const DeviceCommandId_t MOUNTING = 41;
 static const DeviceCommandId_t CAMERA = 42;
@@ -328,6 +372,15 @@ static const DeviceCommandId_t DISABLE_TIMESTAMP_GENERATION = 85;
 static const DeviceCommandId_t ENABLE_TIMESTAMP_GENERATION = 86;
 static constexpr DeviceCommandId_t SET_TIME_FROM_SYS_TIME = 87;
 static constexpr DeviceCommandId_t AUTO_THRESHOLD = 88;
+static constexpr DeviceCommandId_t REQ_AUTO_BLOB = 89;
+static constexpr DeviceCommandId_t REQ_MATCHED_CENTROIDS = 90;
+static constexpr DeviceCommandId_t REQ_BLOB = 91;
+static constexpr DeviceCommandId_t REQ_BLOBS = 92;
+static constexpr DeviceCommandId_t REQ_CENTROID = 93;
+static constexpr DeviceCommandId_t REQ_CENTROIDS = 94;
+static constexpr DeviceCommandId_t ADD_SECONDARY_TM_TO_NORMAL_MODE = 95;
+static constexpr DeviceCommandId_t RESET_SECONDARY_TM_SET = 96;
+static constexpr DeviceCommandId_t READ_SECONDARY_TM_SET = 97;
 static const DeviceCommandId_t NONE = 0xFFFFFFFF;
 
 static const uint32_t VERSION_SET_ID = REQ_VERSION;
@@ -352,6 +405,13 @@ static const uint32_t ALGO_SET_ID = REQ_ALGO;
 static const uint32_t SUBSCRIPTION_SET_ID = REQ_SUBSCRIPTION;
 static const uint32_t LOG_SUBSCRIPTION_SET_ID = REQ_LOG_SUBSCRIPTION;
 static const uint32_t DEBUG_CAMERA_SET_ID = REQ_DEBUG_CAMERA;
+static const uint32_t AUTO_BLOB_SET_ID = REQ_AUTO_BLOB;
+static const uint32_t MATCHED_CENTROIDS_SET_ID = REQ_MATCHED_CENTROIDS;
+static const uint32_t BLOB_SET_ID = REQ_BLOB;
+static const uint32_t BLOBS_SET_ID = REQ_BLOBS;
+static const uint32_t CENTROID_SET_ID = REQ_CENTROID;
+static const uint32_t CENTROIDS_SET_ID = REQ_CENTROIDS;
+static const uint32_t CONTRAST_SET_ID = REQ_CONTRAST;
 
 /** Max size of unencoded frame */
 static const size_t MAX_FRAME_SIZE = 1200;
@@ -412,6 +472,12 @@ static const uint8_t LOG_LEVEL = 3;
 static const uint8_t LOG_SUBSCRIPTION = 19;
 static const uint8_t DEBUG_CAMERA = 20;
 static const uint8_t AUTO_THRESHOLD = 23;
+static constexpr uint8_t BLOB = 25;
+static constexpr uint8_t BLOBS = 36;
+static constexpr uint8_t CENTROID = 26;
+static constexpr uint8_t CENTROIDS = 37;
+static constexpr uint8_t AUTO_BLOB = 39;
+static constexpr uint8_t MATCHED_CENTROIDS = 40;
 }  // namespace ID
 
 namespace Program {
@@ -474,8 +540,6 @@ static const uint32_t FLASH_REGION_SIZE = 0x20000;
  */
 class TemperatureSet : public StaticLocalDataSet<TEMPERATURE_SET_ENTRIES> {
  public:
-  static const size_t SIZE = 24;
-
   TemperatureSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TEMPERATURE_SET_ID) {}
 
   TemperatureSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, TEMPERATURE_SET_ID)) {}
@@ -505,8 +569,6 @@ class TemperatureSet : public StaticLocalDataSet<TEMPERATURE_SET_ENTRIES> {
  */
 class VersionSet : public StaticLocalDataSet<VERSION_SET_ENTRIES> {
  public:
-  static const size_t SIZE = 15;
-
   VersionSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, VERSION_SET_ID) {}
 
   VersionSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, VERSION_SET_ID)) {}
@@ -536,8 +598,6 @@ class VersionSet : public StaticLocalDataSet<VERSION_SET_ENTRIES> {
  */
 class InterfaceSet : public StaticLocalDataSet<INTERFACE_SET_ENTRIES> {
  public:
-  static const size_t SIZE = 20;
-
   InterfaceSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, REQ_INTERFACE) {}
 
   InterfaceSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, REQ_INTERFACE)) {}
@@ -565,8 +625,6 @@ class InterfaceSet : public StaticLocalDataSet<INTERFACE_SET_ENTRIES> {
  */
 class PowerSet : public StaticLocalDataSet<POWER_SET_ENTRIES> {
  public:
-  static const size_t SIZE = 76;
-
   PowerSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, REQ_INTERFACE) {}
 
   PowerSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, REQ_INTERFACE)) {}
@@ -630,8 +688,6 @@ class PowerSet : public StaticLocalDataSet<POWER_SET_ENTRIES> {
  */
 class TimeSet : public StaticLocalDataSet<TIME_SET_ENTRIES> {
  public:
-  static const size_t SIZE = 24;
-
   TimeSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TIME_SET_ID) {}
 
   TimeSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, TIME_SET_ID)) {}
@@ -658,15 +714,13 @@ class TimeSet : public StaticLocalDataSet<TIME_SET_ENTRIES> {
  */
 class SolutionSet : public StaticLocalDataSet<SOLUTION_SET_ENTRIES> {
  public:
-  static const size_t SIZE = 79;
-
   SolutionSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, SOLUTION_SET_ID) {}
 
   SolutionSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, SOLUTION_SET_ID)) {}
 
   // Ticks timestamp
   lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_SOLUTION_SET, this);
-  /// Unix time stamp
+  // Unix time stamp
   lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_SOLUTION_SET, this);
   // Calibrated quaternion (takes into account the mounting quaternion), typically same as
   // track q values
@@ -1381,6 +1435,123 @@ class ValidationSet : public StaticLocalDataSet<VALIDATION_SET_ENTRIES> {
   }
 };
 
+class AutoBlobSet : public StaticLocalDataSet<3> {
+ public:
+  AutoBlobSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, AUTO_BLOB_SET_ID) {}
+  // Ticks timestamp
+  lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_AUTO_BLOB, this);
+  // Unix time stamp
+  lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_AUTO_BLOB, this);
+  lp_var_t<float> threshold = lp_var_t<float>(sid.objectId, PoolIds::AUTO_BLOB_THRESHOLD, this);
+
+ private:
+};
+
+class MatchedCentroidsSet : public StaticLocalDataSet<20> {
+ public:
+  MatchedCentroidsSet(HasLocalDataPoolIF* owner)
+      : StaticLocalDataSet(owner, MATCHED_CENTROIDS_SET_ID) {}
+  MatchedCentroidsSet(object_id_t objectId)
+      : StaticLocalDataSet(sid_t(objectId, MATCHED_CENTROIDS_SET_ID)) {}
+  // Ticks timestamp
+  lp_var_t<uint32_t> ticks =
+      lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_MATCHED_CENTROIDS, this);
+  // Unix time stamp
+  lp_var_t<uint64_t> timeUs =
+      lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_MATCHED_CENTROIDS, this);
+  lp_var_t<uint8_t> numberOfMatchedCentroids =
+      lp_var_t<uint8_t>(sid.objectId, PoolIds::NUM_MATCHED_CENTROIDS, this);
+  lp_vec_t<uint32_t, 16> starIds =
+      lp_vec_t<uint32_t, 16>(sid.objectId, PoolIds::MATCHED_CENTROIDS_STAR_IDS, this);
+  lp_vec_t<float, 16> xCoords =
+      lp_vec_t<float, 16>(sid.objectId, PoolIds::MATCHED_CENTROIDS_X_COORDS, this);
+  lp_vec_t<float, 16> yCoords =
+      lp_vec_t<float, 16>(sid.objectId, PoolIds::MATCHED_CENTROIDS_Y_COORDS, this);
+  lp_vec_t<float, 16> xErrors =
+      lp_vec_t<float, 16>(sid.objectId, PoolIds::MATCHED_CENTROIDS_X_ERRORS, this);
+  lp_vec_t<float, 16> yErrors =
+      lp_vec_t<float, 16>(sid.objectId, PoolIds::MATCHED_CENTROIDS_Y_ERRORS, this);
+
+ private:
+};
+
+class BlobSet : public StaticLocalDataSet<5> {
+ public:
+  BlobSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, BLOB_SET_ID) {}
+  // The blob count received from the Blob Telemetry Set (ID 25)
+  // Ticks timestamp
+  lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::BLOB_TICKS, this);
+  // Unix time stamp
+  lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::BLOB_TIME, this);
+  lp_var_t<uint32_t> blobCount = lp_var_t<uint32_t>(sid.objectId, PoolIds::BLOB_COUNT, this);
+};
+
+class BlobsSet : public StaticLocalDataSet<10> {
+ public:
+  BlobsSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, BLOBS_SET_ID) {}
+  // Ticks timestamp
+  lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::BLOBS_TICKS, this);
+  // Unix time stamp
+  lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::BLOBS_TIME, this);
+  lp_var_t<uint16_t> blobsCount = lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOBS_COUNT, this);
+  lp_var_t<uint16_t> blobsCountUsed =
+      lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOBS_COUNT_USED, this);
+  lp_var_t<uint16_t> nr4LinesSkipped =
+      lp_var_t<uint16_t>(sid.objectId, PoolIds::BLOBS_NR_4LINES_SKIPPED, this);
+  lp_vec_t<uint16_t, 8> xCoords =
+      lp_vec_t<uint16_t, 8>(sid.objectId, PoolIds::BLOBS_X_COORDS, this);
+  lp_vec_t<uint16_t, 8> yCoords =
+      lp_vec_t<uint16_t, 8>(sid.objectId, PoolIds::BLOBS_Y_COORDS, this);
+};
+
+class CentroidSet : public StaticLocalDataSet<5> {
+ public:
+  CentroidSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CENTROID_SET_ID) {}
+
+  // Data received from the Centroid Telemetry Set (ID 26)
+  // Ticks timestamp
+  lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::CENTROID_TICKS, this);
+  // Unix time stamp
+  lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::CENTROID_TIME, this);
+  // The centroid count received from the Centroid Telemetry Set (ID 26)
+  lp_var_t<uint32_t> centroidCount =
+      lp_var_t<uint32_t>(sid.objectId, PoolIds::CENTROID_COUNT, this);
+};
+
+class CentroidsSet : public StaticLocalDataSet<10> {
+ public:
+  CentroidsSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CENTROIDS_SET_ID) {}
+
+  // Data received from the Centroids Telemetry Set (ID 37)
+  lp_var_t<uint32_t> ticksCentroidsTm =
+      lp_var_t<uint32_t>(sid.objectId, PoolIds::CENTROIDS_TICKS, this);
+  // Unix time stamp
+  lp_var_t<uint64_t> timeUsCentroidsTm =
+      lp_var_t<uint64_t>(sid.objectId, PoolIds::CENTROIDS_TIME, this);
+  lp_var_t<uint16_t> centroidsCount =
+      lp_var_t<uint16_t>(sid.objectId, PoolIds::CENTROIDS_COUNT, this);
+  lp_vec_t<float, 16> centroidsXCoords =
+      lp_vec_t<float, 16>(sid.objectId, PoolIds::CENTROIDS_X_COORDS, this);
+  lp_vec_t<float, 16> centroidsYCoords =
+      lp_vec_t<float, 16>(sid.objectId, PoolIds::CENTROIDS_Y_COORDS, this);
+  lp_vec_t<uint8_t, 16> centroidsMagnitudes =
+      lp_vec_t<uint8_t, 16>(sid.objectId, PoolIds::CENTROIDS_MAGNITUDES, this);
+};
+
+class ContrastSet : public StaticLocalDataSet<8> {
+ public:
+  ContrastSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CONTRAST_SET_ID) {}
+
+  // Data received from the Centroids Telemetry Set (ID 29)
+  lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::CONTRAST_TICKS, this);
+  // Unix time stamp
+  lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::CONTRAST_TIME, this);
+  lp_vec_t<uint32_t, 9> contrastA = lp_vec_t<uint32_t, 9>(sid.objectId, PoolIds::CONTRAST_A, this);
+  lp_vec_t<uint32_t, 9> contrastB = lp_vec_t<uint32_t, 9>(sid.objectId, PoolIds::CONTRAST_B, this);
+  lp_vec_t<uint32_t, 9> contrastC = lp_vec_t<uint32_t, 9>(sid.objectId, PoolIds::CONTRAST_C, this);
+  lp_vec_t<uint32_t, 9> contrastD = lp_vec_t<uint32_t, 9>(sid.objectId, PoolIds::CONTRAST_D, this);
+};
+
 /**
  * @brief   Will store the requested algo parameters
  */

mission/cfdp/CfdpFaultHandler.h

@@ -1,28 +1,35 @@
 #ifndef MISSION_CFDP_CFDPFAULTHANDLER_H_
 #define MISSION_CFDP_CFDPFAULTHANDLER_H_
 
+#include "defs.h"
 #include "fsfw/cfdp.h"
 
 namespace cfdp {
 
-class EiveFaultHandler : public cfdp::FaultHandlerBase {
+class EiveFaultHandler : public cfdp::FaultHandlerBase, public SystemObject {
  public:
+  EiveFaultHandler(object_id_t objectId) : SystemObject(objectId) {}
+
   void noticeOfSuspensionCb(cfdp::TransactionId& id, cfdp::ConditionCode code) override {
     sif::warning << "Notice of suspension detected for transaction " << id
                  << " with condition code: " << cfdp::getConditionCodeString(code) << std::endl;
+    triggerEvent(cfdp::FAULT_HANDLER_TRIGGERED, FaultHandlerCode::NOTICE_OF_SUSPENSION, code);
   }
   void noticeOfCancellationCb(cfdp::TransactionId& id, cfdp::ConditionCode code) override {
     sif::warning << "Notice of suspension detected for transaction " << id
                  << " with condition code: " << cfdp::getConditionCodeString(code) << std::endl;
+    triggerEvent(cfdp::FAULT_HANDLER_TRIGGERED, FaultHandlerCode::NOTICE_OF_CANCELLATION, code);
   }
   void abandonCb(cfdp::TransactionId& id, cfdp::ConditionCode code) override {
     sif::warning << "Transaction " << id
                  << " was abandoned, condition code : " << cfdp::getConditionCodeString(code)
                  << std::endl;
+    triggerEvent(cfdp::FAULT_HANDLER_TRIGGERED, FaultHandlerCode::ABANDON_TRANSACTION, code);
   }
   void ignoreCb(cfdp::TransactionId& id, cfdp::ConditionCode code) override {
     sif::warning << "Fault ignored for transaction " << id
                  << ", condition code: " << cfdp::getConditionCodeString(code) << std::endl;
+    triggerEvent(cfdp::FAULT_HANDLER_TRIGGERED, FaultHandlerCode::IGNORE_ERROR, code);
   }
 };
 

mission/cfdp/CfdpHandler.cpp

@@ -16,7 +16,7 @@ using namespace returnvalue;
 using namespace cfdp;
 
 CfdpHandler::CfdpHandler(const FsfwHandlerParams& fsfwHandlerParams, const CfdpHandlerCfg& cfdpCfg,
-    const std::atomic_bool& throttleSignal)
+                         const std::atomic_bool& throttleSignal)
     : SystemObject(fsfwHandlerParams.objectId),
       pduQueue(fsfwHandlerParams.tmtcQueue),
       cfdpRequestQueue(fsfwHandlerParams.cfdpQueue),
@@ -60,7 +60,7 @@ ReturnValue_t CfdpHandler::initialize() {
     result = handleCfdpMessages();
     if (result != OK) {
     }
-    uint32_t fsmCount = 0;
+    uint32_t fsmCount = 1;
     const DestHandler::FsmResult& destResult = destHandler.stateMachine();
     while (destResult.callStatus == CallStatus::CALL_AGAIN) {
       if (fsmCount == config::CFDP_MAX_FSM_CALL_COUNT_DEST_HANDLER) {
@@ -70,7 +70,7 @@ ReturnValue_t CfdpHandler::initialize() {
       destHandler.stateMachine();
       fsmCount++;
     }
-    fsmCount = 0;
+    fsmCount = 1;
 
     throttlePeriodOngoing = throttleSignal;
 
@@ -78,6 +78,9 @@ ReturnValue_t CfdpHandler::initialize() {
     // way without requiring huge amounts of memory for large files.
     if (!throttlePeriodOngoing) {
       const SourceHandler::FsmResult& srcResult = srcHandler.stateMachine();
+      if (srcResult.packetsSent > 0) {
+        signals::CFDP_MSG_COUNTER.fetch_add(srcResult.packetsSent, std::memory_order_relaxed);
+      }
       while (srcResult.callStatus == CallStatus::CALL_AGAIN) {
         // Limit number of messages.
         if (fsmCount == config::CFDP_MAX_FSM_CALL_COUNT_SRC_HANDLER) {
@@ -85,6 +88,9 @@ ReturnValue_t CfdpHandler::initialize() {
           break;
         }
         srcHandler.stateMachine();
+        if (srcResult.packetsSent > 0) {
+          signals::CFDP_MSG_COUNTER.fetch_add(srcResult.packetsSent, std::memory_order_relaxed);
+        }
         if (srcResult.result == cfdp::TM_STORE_FULL) {
           sif::warning << "CFDP Source Handler: TM store is full" << std::endl;
         } else if (srcResult.result == cfdp::TARGET_MSG_QUEUE_FULL) {

mission/cfdp/CfdpHandler.h

@@ -63,7 +63,7 @@ struct CfdpHandlerCfg {
 class CfdpHandler : public SystemObject, public ExecutableObjectIF, public AcceptsTelecommandsIF {
  public:
   explicit CfdpHandler(const FsfwHandlerParams& fsfwParams, const CfdpHandlerCfg& cfdpCfg,
-      const std::atomic_bool& throttleSignal);
+                       const std::atomic_bool& throttleSignal);
 
   [[nodiscard]] const char* getName() const override;
   [[nodiscard]] uint32_t getIdentifier() const override;

mission/cfdp/defs.h

@@ -0,0 +1,16 @@
+#ifndef MISSION_CFDP_DEFS_H_
+#define MISSION_CFDP_DEFS_H_
+
+#include "eive/eventSubsystemIds.h"
+#include "fsfw/events/Event.h"
+
+namespace cfdp {
+
+static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CFDP_APP;
+
+//! [EXPORT] : [COMMENT] P1: CFDP fault handler code. P2: CFDP condition code.
+static constexpr Event FAULT_HANDLER_TRIGGERED = event::makeEvent(SUBSYSTEM_ID, 0, severity::LOW);
+
+}  // namespace cfdp
+
+#endif /* MISSION_CFDP_DEFS_H_ */

mission/com/LiveTmTask.cpp

@@ -9,6 +9,7 @@
 
 static constexpr bool DEBUG_TM_QUEUE_SPEED = false;
 std::atomic_bool signals::CFDP_CHANNEL_THROTTLE_SIGNAL = false;
+std::atomic_uint32_t signals::CFDP_MSG_COUNTER = 0;
 
 LiveTmTask::LiveTmTask(object_id_t objectId, PusTmFunnel& pusFunnel, CfdpTmFunnel& cfdpFunnel,
                        VirtualChannel& channel, const std::atomic_bool& ptmeLocked,
@@ -36,7 +37,8 @@ ReturnValue_t LiveTmTask::performOperation(uint8_t opCode) {
     // TODO: Must read CFDP TM queue and regular TM queue and forward them. Handle regular queue
     //       first.
     handledTm = false;
-    if (!channel.isBusy()) {
+    updateBusyFlag();
+    if (!channelIsBusy) {
       result = handleRegularTmQueue();
       if (result == MessageQueueIF::EMPTY) {
         result = handleCfdpTmQueue();
@@ -51,20 +53,14 @@ ReturnValue_t LiveTmTask::performOperation(uint8_t opCode) {
             consecutiveRegularCounter++;
           }
         }
-      }
-    } else {
-      consecutiveNoBlockWriteCounter = 0;
-    }
-    if (channel.isBusy() and !throttlePeriodOngoing) {
-      // Throttle CFDP packet creator. It is by far the most relevant data creator, so throttling
-      // it is the easiest way to handle back pressure for now in a sensible way.
-      throttleCfdp();
-    } else if(!channel.isBusy() and throttlePeriodOngoing) {
-      if(minimumPeriodThrottleCd.hasTimedOut() and consecutiveNoBlockWriteCounter >= 10) {
-        sif::debug << "releasing cfdp" << std::endl;
-        releaseCfdp();
+      } else if (result != MessageQueueIF::EMPTY) {
+        sif::warning << "LiveTmTask: TM queue failure, returncode 0x" << std::hex << std::setw(4)
+                     << result << std::dec << std::endl;
       }
     }
+
+    cfdpBackpressureHandling();
+
     if (!handledTm) {
       if (tmFunnelCd.hasTimedOut()) {
         pusFunnel.performOperation(0);
@@ -75,10 +71,10 @@ ReturnValue_t LiveTmTask::performOperation(uint8_t opCode) {
       readCommandQueue();
       if (DEBUG_TM_QUEUE_SPEED) {
         if (consecutiveCfdpCounter > 0) {
-          sif::debug << "Concecutive CFDP TM handled: " << consecutiveCfdpCounter << std::endl;
+          sif::debug << "Consecutive CFDP TM handled: " << consecutiveCfdpCounter << std::endl;
         }
         if (consecutiveRegularCounter > 0) {
-          sif::debug << "Concecutive regular TM handled: " << consecutiveRegularCounter
+          sif::debug << "Consecutive regular TM handled: " << consecutiveRegularCounter
                      << std::endl;
         }
         consecutiveRegularCounter = 0;
@@ -144,16 +140,24 @@ void LiveTmTask::readCommandQueue(void) {
   }
 }
 
-ReturnValue_t LiveTmTask::handleRegularTmQueue() { return handleGenericTmQueue(*regularTmQueue); }
+ReturnValue_t LiveTmTask::handleRegularTmQueue() {
+  return handleGenericTmQueue(*regularTmQueue, false);
+}
 
-ReturnValue_t LiveTmTask::handleCfdpTmQueue() { return handleGenericTmQueue(*cfdpTmQueue); }
+ReturnValue_t LiveTmTask::handleCfdpTmQueue() { return handleGenericTmQueue(*cfdpTmQueue, true); }
 
-ReturnValue_t LiveTmTask::handleGenericTmQueue(MessageQueueIF& queue) {
+ReturnValue_t LiveTmTask::handleGenericTmQueue(MessageQueueIF& queue, bool isCfdp) {
   TmTcMessage message;
   ReturnValue_t result = queue.receiveMessage(&message);
   if (result == MessageQueueIF::EMPTY) {
     return result;
   }
+  if (isCfdp and signals::CFDP_MSG_COUNTER > 0) {
+    signals::CFDP_MSG_COUNTER--;
+  }
+  if (DEBUG_CFDP_TO_LIVE_TM_TASK and signals::CFDP_MSG_COUNTER > 0) {
+    sif::debug << "LiveTmTask: CFDP message counter: " << signals::CFDP_MSG_COUNTER << std::endl;
+  }
   store_address_t storeId = message.getStorageId();
   const uint8_t* data = nullptr;
   size_t size = 0;
@@ -165,26 +169,19 @@ ReturnValue_t LiveTmTask::handleGenericTmQueue(MessageQueueIF& queue) {
     return result;
   }
 
-  if(ptmeLocked) {
-    consecutiveNoBlockWriteCounter= 0;
-  }
   if (!ptmeLocked) {
-    size_t partiallyWrittenSize = 0;
-    result = channel.write(data, size, partiallyWrittenSize);
+    size_t writtenSize = 0;
+    result = channel.write(data, size, writtenSize);
     if (result == DirectTmSinkIF::PARTIALLY_WRITTEN) {
-      consecutiveNoBlockWriteCounter = 0;
-      // Already throttle CFDP.
-      throttleCfdp();
-      result = channel.handleLastWriteSynchronously(data, size, partiallyWrittenSize, 200);
+      result = channel.handleWriteCompletionSynchronously(writtenSize, 200);
       if (result != returnvalue::OK) {
         // TODO: Event? Might lead to dangerous spam though..
-        sif::warning
-            << "LiveTmTask: Synchronous write of last segment failed with code 0x"
-            << std::setw(4) << std::hex << result << std::dec << std::endl;
+        sif::warning << "LiveTmTask: Synchronous write of last segment failed with code 0x"
+                     << std::setw(4) << std::hex << result << std::dec << std::endl;
       }
-      minimumPeriodThrottleCd.resetTimer();
-    } else {
-      consecutiveNoBlockWriteCounter++;
+    } else if (result != returnvalue::OK) {
+      sif::error << "LiveTmTask: Channel write failed with code 0x" << std::hex << std::setw(4)
+                 << result << std::dec << std::endl;
     }
   }
   // Try delete in any case, ignore failures (which should not happen), it is more important to
@@ -195,13 +192,38 @@ ReturnValue_t LiveTmTask::handleGenericTmQueue(MessageQueueIF& queue) {
 
 void LiveTmTask::throttleCfdp() {
   throttlePeriodOngoing = true;
-  minimumPeriodThrottleCd.resetTimer();
   signals::CFDP_CHANNEL_THROTTLE_SIGNAL = true;
+  if (DEBUG_CFDP_TO_LIVE_TM_TASK) {
+    sif::debug << "Throttling CFDP" << std::endl;
+  }
 }
 
 void LiveTmTask::releaseCfdp() {
   throttlePeriodOngoing = false;
   signals::CFDP_CHANNEL_THROTTLE_SIGNAL = false;
+  if (DEBUG_CFDP_TO_LIVE_TM_TASK) {
+    sif::debug << "Releasing CFDP" << std::endl;
+  }
+}
+
+void LiveTmTask::updateBusyFlag() {
+  // We cache this as a member, because the busy bit can toggle very quickly..
+  channelIsBusy = channel.isBusy();
+}
+
+void LiveTmTask::cfdpBackpressureHandling() {
+  if (channelIsBusy and !throttlePeriodOngoing) {
+    // Throttle CFDP packet creator. It is by far the most relevant data creator, so throttling
+    // it is the easiest way to handle back pressure for now in a sensible way.
+    if (signals::CFDP_MSG_COUNTER >= (config::LIVE_CHANNEL_CFDP_QUEUE_SIZE / 2)) {
+      throttleCfdp();
+    }
+  } else if (!channelIsBusy and throttlePeriodOngoing) {
+    // Half full/empty flow control: Release the CFDP is the queue is empty enough.
+    if (signals::CFDP_MSG_COUNTER <= (config::LIVE_CHANNEL_CFDP_QUEUE_SIZE / 4)) {
+      releaseCfdp();
+    }
+  }
 }
 
 ModeTreeChildIF& LiveTmTask::getModeTreeChildIF() { return *this; }

mission/com/LiveTmTask.h

@@ -10,9 +10,13 @@
 #include <mission/com/VirtualChannelWithQueue.h>
 #include <mission/tmtc/CfdpTmFunnel.h>
 #include <mission/tmtc/PusTmFunnel.h>
+
 #include <cstdint>
+
 #include "eive/definitions.h"
 
+static constexpr bool DEBUG_CFDP_TO_LIVE_TM_TASK = false;
+
 class LiveTmTask : public SystemObject,
                    public HasModesIF,
                    public ExecutableObjectIF,
@@ -37,26 +41,25 @@ class LiveTmTask : public SystemObject,
   ModeHelper modeHelper;
   Mode_t mode = HasModesIF::MODE_OFF;
   Countdown tmFunnelCd = Countdown(100);
-  uint32_t consecutiveNoBlockWriteCounter = 0;
   PusTmFunnel& pusFunnel;
   CfdpTmFunnel& cfdpFunnel;
   VirtualChannel& channel;
   const std::atomic_bool& ptmeLocked;
-  // This countdown ensures that the CFDP is always throttled with a minimum period. Only after
-  // this period, the CFDP can be released if the channel is not busy.
-  Countdown minimumPeriodThrottleCd = Countdown(config::CFDP_THROTTLE_PERIOD_MS);
   bool throttlePeriodOngoing = false;
+  bool channelIsBusy = false;
 
   void readCommandQueue(void);
 
   ReturnValue_t handleRegularTmQueue();
   ReturnValue_t handleCfdpTmQueue();
-  ReturnValue_t handleGenericTmQueue(MessageQueueIF& queue);
+  ReturnValue_t handleGenericTmQueue(MessageQueueIF& queue, bool isCfdp);
 
   MessageQueueId_t getCommandQueue() const override;
 
   void getMode(Mode_t* mode, Submode_t* submode) override;
 
+  void cfdpBackpressureHandling();
+
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                  uint32_t* msToReachTheMode) override;
 
@@ -65,6 +68,7 @@ class LiveTmTask : public SystemObject,
   void announceMode(bool recursive) override;
   void throttleCfdp();
   void releaseCfdp();
+  void updateBusyFlag();
 
   object_id_t getObjectId() const override;
   const HasHealthIF* getOptHealthIF() const override;

mission/com/TmStoreTaskBase.cpp

@@ -138,11 +138,10 @@ ReturnValue_t TmStoreTaskBase::performDump(PersistentTmStoreWithTmQueue& store,
     return result;
   }
   dumpedLen = tmReader.getFullPacketLen();
-  size_t partiallyWrittenSize = 0;
-  result = channel.write(tmReader.getFullData(), dumpedLen, partiallyWrittenSize);
+  size_t writtenSize = 0;
+  result = channel.write(tmReader.getFullData(), dumpedLen, writtenSize);
   if (result == VirtualChannelIF::PARTIALLY_WRITTEN) {
-    result = channel.handleLastWriteSynchronously(tmReader.getFullData(), partiallyWrittenSize,
-                                                  dumpedLen - partiallyWrittenSize, 200);
+    result = channel.handleWriteCompletionSynchronously(writtenSize, 200);
     if (result != returnvalue::OK) {
       // TODO: Event? Might lead to dangerous spam though..
       sif::warning << "PersistentTmStore: Synchronous write of last segment failed with code 0x"

mission/com/VirtualChannel.cpp

@@ -21,11 +21,18 @@ ReturnValue_t VirtualChannel::write(const uint8_t* data, size_t size, size_t& wr
 
 uint8_t VirtualChannel::getVcid() const { return vcId; }
 
-ReturnValue_t VirtualChannel::finishWrite(const uint8_t* data, size_t start, size_t remainingSize) {
+ReturnValue_t VirtualChannel::advanceWrite(size_t& writtenSize) {
   if (!ptme.containsVc(vcId)) {
     return CHANNEL_DOES_NOT_EXIST;
   }
-  return ptme.getVirtChannel(vcId)->finishWrite(data, start, remainingSize);
+  return ptme.getVirtChannel(vcId)->advanceWrite(writtenSize);
+}
+
+bool VirtualChannel::writeActive() const {
+  if (!ptme.containsVc(vcId)) {
+    return CHANNEL_DOES_NOT_EXIST;
+  }
+  return ptme.getVirtChannel(vcId)->writeActive();
 }
 
 const char* VirtualChannel::getName() const { return vcName.c_str(); }
@@ -46,20 +53,26 @@ void VirtualChannel::cancelTransfer() {
 
 bool VirtualChannel::isTxOn() const { return txOn; }
 
-ReturnValue_t VirtualChannel::handleLastWriteSynchronously(const uint8_t* data, size_t start,
-                                                           size_t remLen, unsigned maxDelayMs) {
+ReturnValue_t VirtualChannel::handleWriteCompletionSynchronously(size_t& writtenSize,
+                                                                 unsigned maxCompletionTimeMs) {
   unsigned delayMs = 0;
   while (true) {
     if (isBusy()) {
-      if (delayMs >= maxDelayMs) {
+      if (delayMs >= maxCompletionTimeMs) {
         break;
       }
       TaskFactory::delayTask(10);
       delayMs += 10;
       continue;
     }
-    sif::debug << "last write after" << delayMs << std::endl;
-    return finishWrite(data, start, remLen);
+    ReturnValue_t result = advanceWrite(writtenSize);
+    if (result == returnvalue::OK) {
+      // Transfer complete
+      return result;
+    } else if (result != PARTIALLY_WRITTEN) {
+      // Some error where we can not or should not continue the transfer.
+      return result;
+    }
   }
   return returnvalue::FAILED;
 }

mission/com/VirtualChannel.h

@@ -32,9 +32,10 @@ class VirtualChannel : public SystemObject, public VirtualChannelIF {
   ReturnValue_t sendNextTm(const uint8_t* data, size_t size, size_t& writtenSize);
   bool isBusy() const override;
   ReturnValue_t write(const uint8_t* data, size_t size, size_t& writtenSize) override;
-  ReturnValue_t finishWrite(const uint8_t* data, size_t start, size_t remainingSize) override;
-  ReturnValue_t handleLastWriteSynchronously(const uint8_t* data, size_t start, size_t remLen,
-                                             unsigned maxDelayMs);
+  ReturnValue_t advanceWrite(size_t& writtenSize) override;
+  ReturnValue_t handleWriteCompletionSynchronously(size_t& writtenSize,
+                                                   unsigned maxCompletionTimeMs);
+  bool writeActive() const override;
   void cancelTransfer() override;
   uint8_t getVcid() const;
   bool isTxOn() const;

mission/com/VirtualChannelWithQueue.cpp

@@ -37,11 +37,11 @@ ReturnValue_t VirtualChannelWithQueue::handleNextTm(bool performWriteOp) {
   }
 
   // TODO: Hnadle partial write handling
-  size_t partiallyWrittenSize = 0;
+  size_t writtenSize = 0;
   if (performWriteOp) {
-    result = write(data, size, partiallyWrittenSize);
+    result = write(data, size, writtenSize);
     if (result == PARTIALLY_WRITTEN) {
-      result = handleLastWriteSynchronously(data, size, partiallyWrittenSize, 200);
+      result = handleWriteCompletionSynchronously(writtenSize, 200);
       if (result != returnvalue::OK) {
         // TODO: Event? Might lead to dangerous spam though..
         sif::warning

mission/controller/PowerController.cpp

@@ -100,15 +100,16 @@ void PowerController::performControlOperation() {
       return;
     }
     case InternalState::READY: {
+      if (mode != MODE_NORMAL) {
+        PoolReadGuard pg(&enablePl);
+        if (pg.getReadResult() == returnvalue::OK) {
+          enablePl.setValidity(false, true);
+        }
+      }
       if (mode != MODE_OFF) {
         calculateStateOfCharge();
         if (mode == MODE_NORMAL) {
           watchStateOfCharge();
-        } else {
-          PoolReadGuard pg(&enablePl);
-          if (pg.getReadResult() == returnvalue::OK) {
-            enablePl.setValidity(false, true);
-          }
         }
       }
       break;

mission/controller/PowerController.h

@@ -53,13 +53,13 @@ class PowerController : public ExtendedControllerBase, public ReceivesParameterM
   ReturnValue_t calculateCoulombCounterChargeUpperThreshold();
 
   // Parameters
-  float batteryInternalResistance = 70.0 / 2.0 / 1000.0;  // [Ohm]
-  float batteryMaximumCapacity = 2.6 * 2;                 // [Ah]
-  float coulombCounterVoltageUpperThreshold = 16.2;       // [V]
-  double maxAllowedTimeDiff = 1.5;                        // [s]
-  float payloadOpLimitOn = 0.90;                          // [%]
-  float payloadOpLimitLow = 0.75;                         // [%]
-  float higherModesLimit = 0.6;                           // [%]
+  float batteryInternalResistance = 0.06798200367;   // [Ohm]
+  float batteryMaximumCapacity = 2.6 * 2;            // [Ah]
+  float coulombCounterVoltageUpperThreshold = 16.2;  // [V]
+  double maxAllowedTimeDiff = 1.5;                   // [s]
+  float payloadOpLimitOn = 0.90;                     // [%]
+  float payloadOpLimitLow = 0.75;                    // [%]
+  float higherModesLimit = 0.6;                      // [%]
 
   // OCV Look-up-Table {[Ah],[V]}
   static constexpr uint8_t LOOK_UP_TABLE_MAX_IDX = 99;

mission/genericFactory.cpp

@@ -86,7 +86,6 @@ EntityId REMOTE_CFDP_ID(UnsignedByteField<uint16_t>(config::EIVE_GROUND_CFDP_ENT
 RemoteEntityCfg GROUND_REMOTE_CFG(REMOTE_CFDP_ID);
 OneRemoteConfigProvider REMOTE_CFG_PROVIDER(GROUND_REMOTE_CFG);
 HostFilesystem HOST_FS;
-EiveFaultHandler EIVE_FAULT_HANDLER;
 
 }  // namespace cfdp
 
@@ -118,7 +117,7 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
 
   {
     PoolManager::LocalPoolConfig poolCfg = {{600, 32},  {400, 64},   {400, 128},
-                                            {350, 512}, {500, 1200}, {100, 2048}};
+                                            {400, 512}, {800, 1200}, {150, 2048}};
     *tmStore = new PoolManager(objects::TM_STORE, poolCfg);
   }
 
@@ -290,7 +289,8 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
   cfdp::EntityId localId(apid);
   GROUND_REMOTE_CFG.defaultChecksum = cfdp::ChecksumType::CRC_32;
   GROUND_REMOTE_CFG.maxFileSegmentLen = config::CFDP_MAX_FILE_SEGMENT_LEN;
-  CfdpHandlerCfg cfdpCfg(localId, indicationCfg, *eiveUserHandler, EIVE_FAULT_HANDLER, PACKET_LIST,
+  auto eiveFaultHandler = new EiveFaultHandler(objects::CFDP_FAULT_HANDLER);
+  CfdpHandlerCfg cfdpCfg(localId, indicationCfg, *eiveUserHandler, *eiveFaultHandler, PACKET_LIST,
                          LOST_SEGMENTS, REMOTE_CFG_PROVIDER);
   auto* cfdpHandler = new CfdpHandler(params, cfdpCfg, signals::CFDP_CHANNEL_THROTTLE_SIGNAL);
   // All CFDP packets arrive wrapped inside CCSDS space packets

mission/payload/PayloadPcduHandler.cpp

@@ -395,7 +395,6 @@ void PayloadPcduHandler::quickTransitionBackToOff(bool startTransitionToOff, boo
 
 void PayloadPcduHandler::checkAdcValues() {
   using namespace plpcdu;
-  checkJsonFileInit();
   adcSet.processed[U_BAT_DIV_6] =
       static_cast<float>(adcSet.channels[0]) * VOLTAGE_DIV / MAX122X_BIT * MAX122X_VREF;
   adcSet.processed[U_NEG_V_FB] =
@@ -529,6 +528,10 @@ void PayloadPcduHandler::checkJsonFileInit() {
       params.initialize(sdcMan->getCurrentMountPrefix());
       jsonFileInitComplete = true;
     }
+  } else {
+    if (not sdcMan->isSdCardUsable(std::nullopt)) {
+      jsonFileInitComplete = false;
+    }
   }
 }
 
@@ -564,6 +567,13 @@ bool PayloadPcduHandler::checkCurrent(float val, float upperBound, Event event)
   return true;
 }
 
+ReturnValue_t PayloadPcduHandler::initialize() {
+  checkJsonFileInit();
+  return DeviceHandlerBase::initialize();
+}
+
+void PayloadPcduHandler::performOperationHook() { checkJsonFileInit(); }
+
 ReturnValue_t PayloadPcduHandler::checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
                                                    uint32_t* msToReachTheMode) {
   if (commandedMode != MODE_OFF) {

mission/payload/PayloadPcduHandler.h

@@ -67,7 +67,9 @@ class PayloadPcduHandler : public DeviceHandlerBase {
                      SdCardMountedIF* sdcMan, Stack5VHandler& stackHandler, bool periodicPrintout);
 
   void setToGoToNormalModeImmediately(bool enable);
+  void performOperationHook() override;
   void enablePeriodicPrintout(bool enable, uint8_t divider);
+  ReturnValue_t initialize() override;
 
 #ifdef XIPHOS_Q7S
   static ReturnValue_t extConvAsTwoCallback(SpiComIF* comIf, SpiCookie* cookie,

mission/sysDefs.h

@@ -15,6 +15,7 @@ namespace signals {
 
 extern std::atomic_bool CFDP_CHANNEL_THROTTLE_SIGNAL;
 extern std::atomic_uint16_t I2C_FATAL_ERRORS;
+extern std::atomic_uint32_t CFDP_MSG_COUNTER;
 
 }  // namespace signals
 

mission/system/EiveSystem.cpp

@@ -70,6 +70,9 @@ void EiveSystem::performChildOperation() {
   }
   pdecRecoveryLogic();
   i2cRecoveryLogic();
+  if (forcePlOffState != ForcePlOffState::NONE) {
+    forceOffPayload();
+  }
 }
 
 ReturnValue_t EiveSystem::initialize() {
@@ -203,10 +206,14 @@ void EiveSystem::handleEventMessages() {
             break;
           }
           case power::POWER_LEVEL_LOW: {
-            forceOffPayload();
+            forcePlOffState = ForcePlOffState::FORCE_ALL_EXCEPT_SUPV_OFF;
             break;
           }
-          case power::POWER_LEVEL_CRITICAL:
+          case power::POWER_LEVEL_CRITICAL: {
+            // Force payload off in any case. It really should not be on when the power level
+            // becomes critical, but better be safe than sorry..
+            forcePlOffState = ForcePlOffState::FORCE_ALL_EXCEPT_SUPV_OFF;
+            // Also set the STR assembly to faulty, which should cause a fallback to SAFE mode.
             CommandMessage msg;
             HealthMessage::setHealthMessage(&msg, HealthMessage::HEALTH_SET, HasHealthIF::FAULTY);
             ReturnValue_t result = MessageQueueSenderIF::sendMessage(
@@ -216,6 +223,7 @@ void EiveSystem::handleEventMessages() {
                          << std::endl;
             }
             break;
+          }
         }
         break;
       default:
@@ -403,37 +411,45 @@ void EiveSystem::pdecRecoveryLogic() {
 
 void EiveSystem::forceOffPayload() {
   CommandMessage msg;
+  ReturnValue_t result;
   // set PL to faulty
   HealthMessage::setHealthMessage(&msg, HealthMessage::HEALTH_SET, HasHealthIF::FAULTY);
 
-  ReturnValue_t result = commandQueue->sendMessage(plPcduQueueId, &msg);
-  if (result != returnvalue::OK) {
-    sif::error << "EIVE System: Sending FAULTY command to PL PCDU failed" << std::endl;
+  if (forcePlOffState == ForcePlOffState::FORCE_ALL_EXCEPT_SUPV_OFF) {
+    result = commandQueue->sendMessage(plocMpsocQueueId, &msg);
+    if (result != returnvalue::OK) {
+      sif::error << "EIVE System: Sending FAULTY command to PLOC MPSOC failed" << std::endl;
+    }
+    result = commandQueue->sendMessage(cameraQueueId, &msg);
+    if (result != returnvalue::OK) {
+      sif::error << "EIVE System: Sending FAULTY command to PL CAM failed" << std::endl;
+    }
+    result = commandQueue->sendMessage(scexQueueId, &msg);
+    if (result != returnvalue::OK) {
+      sif::error << "EIVE System: Sending FAULTY command to SCEX failed" << std::endl;
+    }
+    result = commandQueue->sendMessage(radSensorQueueId, &msg);
+    if (result != returnvalue::OK) {
+      sif::error << "EIVE System: Sending FAULTY command to RAD SENSOR failed" << std::endl;
+    }
+    result = commandQueue->sendMessage(plPcduQueueId, &msg);
+    if (result != returnvalue::OK) {
+      sif::error << "EIVE System: Sending FAULTY command to PL PCDU failed" << std::endl;
+    }
+    forcePlOffState = ForcePlOffState::WAITING;
+    supvOffDelay.resetTimer();
   }
 
-  result = commandQueue->sendMessage(plocMpsocQueueId, &msg);
-  if (result != returnvalue::OK) {
-    sif::error << "EIVE System: Sending FAULTY command to PLOC MPSOC failed" << std::endl;
+  if (forcePlOffState == ForcePlOffState::WAITING and supvOffDelay.hasTimedOut()) {
+    forcePlOffState = ForcePlOffState::FORCE_SUPV_OFF;
   }
 
-  result = commandQueue->sendMessage(plocSupervisorQueueId, &msg);
-  if (result != returnvalue::OK) {
-    sif::error << "EIVE System: Sending FAULTY command to PLOC SUPERVISOR failed" << std::endl;
-  }
-
-  result = commandQueue->sendMessage(cameraQueueId, &msg);
-  if (result != returnvalue::OK) {
-    sif::error << "EIVE System: Sending FAULTY command to PL CAM failed" << std::endl;
-  }
-
-  result = commandQueue->sendMessage(scexQueueId, &msg);
-  if (result != returnvalue::OK) {
-    sif::error << "EIVE System: Sending FAULTY command to SCEX failed" << std::endl;
-  }
-
-  result = commandQueue->sendMessage(radSensorQueueId, &msg);
-  if (result != returnvalue::OK) {
-    sif::error << "EIVE System: Sending FAULTY command to RAD SENSOR failed" << std::endl;
+  if (forcePlOffState == ForcePlOffState::FORCE_SUPV_OFF) {
+    result = commandQueue->sendMessage(plocSupervisorQueueId, &msg);
+    if (result != returnvalue::OK) {
+      sif::error << "EIVE System: Sending FAULTY command to PLOC SUPERVISOR failed" << std::endl;
+    }
+    forcePlOffState = ForcePlOffState::NONE;
   }
 }
 

mission/system/EiveSystem.h

@@ -22,6 +22,12 @@ class EiveSystem : public Subsystem, public HasActionsIF {
   [[nodiscard]] MessageQueueId_t getCommandQueue() const override;
 
  private:
+  enum class ForcePlOffState {
+    NONE,
+    FORCE_ALL_EXCEPT_SUPV_OFF,
+    WAITING,
+    FORCE_SUPV_OFF
+  } forcePlOffState = ForcePlOffState::NONE;
   enum class I2cRebootState {
     NONE,
     SYSTEM_MODE_BOOT,
@@ -37,6 +43,7 @@ class EiveSystem : public Subsystem, public HasActionsIF {
   bool alreadyTriedI2cRecovery = false;
 
   uint8_t frameDirtyErrorCounter = 0;
+  Countdown supvOffDelay = Countdown(3000);
   Countdown frameDirtyCheckCd = Countdown(10000);
   // If the PDEC reset was already attempted in the last 2 minutes, there is a high chance that
   // only a full reboot will fix the issue.

mission/tmtc/DirectTmSinkIF.h

@@ -14,22 +14,44 @@ class DirectTmSinkIF {
 
   static constexpr ReturnValue_t IS_BUSY = returnvalue::makeCode(CLASS_ID, 0);
   static constexpr ReturnValue_t PARTIALLY_WRITTEN = returnvalue::makeCode(CLASS_ID, 1);
-  static constexpr ReturnValue_t INCOMPLETE_PARTIAL_WRITE = returnvalue::makeCode(CLASS_ID, 2);
+  static constexpr ReturnValue_t NO_WRITE_ACTIVE = returnvalue::makeCode(CLASS_ID, 2);
 
   /**
-   * @brief   Implements the functionality to write to a TM sink directly
+   * @brief   Implements the functionality to write to a TM sink directly.
+   *
+   * The write might not be completed immediately! If PARTIALLY_WRITTEN is returned, the user
+   * should poll the ready for packet status bit and call @advanceWrite continuously until
+   * the transfer is completed.
    *
    * @param data  Pointer to buffer holding the data to write
    * @param size  Number of bytes to write
-   * @return returnvalue::OK on success, returnvalue::FAILED on failure, IS_BUSY
-   *    if the TM sink is busy, PARTIALLY_WRITTEN if only a portion of the bytes could be
-   *    written.
+   * @param writtenSize Size written during write call.
+   * @return returnvalue::OK on full write success, IS_BUSY if a previous write transfer has not
+   *    been completed yet or the PAPB interface is not ready for a packet, PARTIALLY_WRITTEN
+   *    if some bytes were written, but the transfer has not been completed yet.
    */
   virtual ReturnValue_t write(const uint8_t* data, size_t size, size_t& writtenSize) = 0;
 
-  virtual ReturnValue_t finishWrite(const uint8_t* data, size_t start, size_t remainingSize) = 0;
+  /**
+   * Advances a active file transfer.
+   * @param writtenSize
+   * @return returnvalue::OK if the packet write process is complete, PARTIALLY_WRITTEN if
+   *    some bytes were written but the transfer is not complete yet.
+   *    NO_WRITE_ACTIVE if this is called without a valid previous write call.
+   */
+  virtual ReturnValue_t advanceWrite(size_t& writtenSize) = 0;
 
+  /**
+   * Is busy, so no write operation can not be started and write advancement
+   * is not possible.
+   * @return
+   */
   virtual bool isBusy() const = 0;
+  /**
+   * The PAPB interface is currently busy writing a packet and a new packet can not be written yet.
+   * @return
+   */
+  virtual bool writeActive() const = 0;
 };
 
 #endif /* MISSION_TMTC_DIRECTTMSINKIF_H_ */