Merge pull request 'prep v1.42.0' (#549) from prep_v1.42.0 into develop

Reviewed-on: #549

CHANGELOG.md

@@ -16,6 +16,39 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
+# [v1.42.0] 2023-04-01
+
+eive-tmtc: v2.20.1
+q7s-package: v2.3.0
+
+## Changed
+
+- SCEX filename updates. Also use T as the file ID / date separator between date and time.
+- COM TM store and dump handling: Introduce modes for all 4 TM VC/store tasks. The OFF mode can be
+  used to disable ongoing dumps or to prevent writes to the PTME VC. This allows cleaner reset
+  handling of the PTME. All 4 VC/store tasks were attached to the COM mode tree and are commanded
+  as part of the COM sequence as well to ensure consistent state with the CCSDS IP core handler.
+- Added `PTME_LOCKED` boolean lock which is used to lock the PTME so it is not used by the VC tasks
+  anymore. This lock will be controlled by the CCSDS IP core handler and is locked when the PTME
+  needs to be reset. Examples for this are datarate changes.
+- Simulate real PCDU in PCDU dummy by remembering commandes switch change and triggering appropriate
+  events. Switch feedback is still immediate.
+- GomSpace devices are polled with a doubled frequency. This speeds up power switch commanding.
+
+## Fixed
+
+- Bugfix for side lane transitions of the dual lane assemblies, which only worked when the
+  assembly was directly commanded.
+- Syrlinks Handler: Bugfix so transition command is only sent once.
+- SCEX file name bug: Create file name time stamp with `strftime` similarly to how it's done
+  for the persistent TM store.
+
+## Added
+
+- Added GPS0 and GPS1 health device which are used by the ACS board assembly when deciding whether
+  to change to the other side or to go to dual side directly. Setting the health devices to faulty
+  should also trigger a side switch or a switch to dual mode.
+
 # [v1.41.0] 2023-03-28
 
 eive-tmtc: v2.20.0

CMakeLists.txt

@@ -10,7 +10,7 @@
 cmake_minimum_required(VERSION 3.13)
 
 set(OBSW_VERSION_MAJOR 1)
-set(OBSW_VERSION_MINOR 41)
+set(OBSW_VERSION_MINOR 42)
 set(OBSW_VERSION_REVISION 0)
 
 # set(CMAKE_VERBOSE TRUE)
@@ -486,7 +486,8 @@ endif()
 target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_FSFW_NAME}
                                                  ${LIB_OS_NAME})
 
-target_link_libraries(${LIB_DUMMIES} PUBLIC ${LIB_FSFW_NAME} ${LIB_JSON_NAME})
+target_link_libraries(${LIB_DUMMIES} PUBLIC ${LIB_EIVE_MISSION}
+                                            ${LIB_FSFW_NAME} ${LIB_JSON_NAME})
 
 target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_EIVE_MISSION} ${LIB_DUMMIES})
 

bsp_hosted/ObjectFactory.cpp

@@ -29,7 +29,7 @@
 #include <dummies/AcuDummy.h>
 #include <dummies/CoreControllerDummy.h>
 
-#include "dummies/helpers.h"
+#include "dummies/helperFactory.h"
 
 #ifdef PLATFORM_UNIX
 #include <fsfw_hal/linux/serial/SerialComIF.h>

bsp_hosted/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 283 translations.
+ * @brief    Auto-generated event translation file. Contains 284 translations.
  * @details
- * Generated on: 2023-03-28 22:20:01
+ * Generated on: 2023-04-01 15:26:43
  */
 #include "translateEvents.h"
 
@@ -209,6 +209,8 @@ const char *TRANSITION_OTHER_SIDE_FAILED_STRING = "TRANSITION_OTHER_SIDE_FAILED"
 const char *NOT_ENOUGH_DEVICES_DUAL_MODE_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE";
 const char *POWER_STATE_MACHINE_TIMEOUT_STRING = "POWER_STATE_MACHINE_TIMEOUT";
 const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING = "SIDE_SWITCH_TRANSITION_NOT_ALLOWED";
+const char *DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY_STRING =
+    "DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY";
 const char *TRANSITION_OTHER_SIDE_FAILED_12900_STRING = "TRANSITION_OTHER_SIDE_FAILED_12900";
 const char *NOT_ENOUGH_DEVICES_DUAL_MODE_12901_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE_12901";
 const char *POWER_STATE_MACHINE_TIMEOUT_12902_STRING = "POWER_STATE_MACHINE_TIMEOUT_12902";
@@ -700,6 +702,8 @@ const char *translateEvents(Event event) {
       return POWER_STATE_MACHINE_TIMEOUT_STRING;
     case (12803):
       return SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING;
+    case (12804):
+      return DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY_STRING;
     case (12900):
       return TRANSITION_OTHER_SIDE_FAILED_12900_STRING;
     case (12901):

bsp_hosted/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 169 translations.
- * Generated on: 2023-03-28 22:20:01
+ * Contains 171 translations.
+ * Generated on: 2023-04-01 15:26:43
  */
 #include "translateObjects.h"
 
@@ -38,6 +38,8 @@ const char *GYRO_3_L3G_HANDLER_STRING = "GYRO_3_L3G_HANDLER";
 const char *RW4_STRING = "RW4";
 const char *STAR_TRACKER_STRING = "STAR_TRACKER";
 const char *GPS_CONTROLLER_STRING = "GPS_CONTROLLER";
+const char *GPS_0_HEALTH_DEV_STRING = "GPS_0_HEALTH_DEV";
+const char *GPS_1_HEALTH_DEV_STRING = "GPS_1_HEALTH_DEV";
 const char *IMTQ_POLLING_STRING = "IMTQ_POLLING";
 const char *IMTQ_HANDLER_STRING = "IMTQ_HANDLER";
 const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
@@ -242,6 +244,10 @@ const char *translateObject(object_id_t object) {
       return STAR_TRACKER_STRING;
     case 0x44130045:
       return GPS_CONTROLLER_STRING;
+    case 0x44130046:
+      return GPS_0_HEALTH_DEV_STRING;
+    case 0x44130047:
+      return GPS_1_HEALTH_DEV_STRING;
     case 0x44140013:
       return IMTQ_POLLING_STRING;
     case 0x44140014:

bsp_q7s/core/ObjectFactory.cpp

@@ -1,5 +1,6 @@
 #include "ObjectFactory.h"
 
+#include <fsfw/devicehandlers/HealthDevice.h>
 #include <fsfw/subsystem/Subsystem.h>
 #include <linux/acs/AcsBoardPolling.h>
 #include <linux/acs/GpsHyperionLinuxController.h>
@@ -19,15 +20,15 @@
 #include <mission/acs/MgmRm3100CustomHandler.h>
 #include <mission/acs/str/StarTrackerHandler.h>
 #include <mission/acs/str/strHelpers.h>
+#include <mission/com/LiveTmTask.h>
+#include <mission/com/PersistentLogTmStoreTask.h>
+#include <mission/com/PersistentSingleTmStoreTask.h>
 #include <mission/power/CspCookie.h>
 #include <mission/system/acs/ImtqAssembly.h>
+#include <mission/system/acs/StrAssembly.h>
 #include <mission/system/fdir/StrFdir.h>
 #include <mission/system/objects/CamSwitcher.h>
-#include <mission/system/objects/StrAssembly.h>
 #include <mission/system/objects/SyrlinksAssembly.h>
-#include <mission/tmtc/LiveTmTask.h>
-#include <mission/tmtc/PersistentLogTmStoreTask.h>
-#include <mission/tmtc/PersistentSingleTmStoreTask.h>
 
 #include "OBSWConfig.h"
 #include "bsp_q7s/boardtest/Q7STestTask.h"
@@ -80,6 +81,7 @@ using gpio::Levels;
 #include <mission/acs/ImtqHandler.h>
 #include <mission/acs/rwHelpers.h>
 #include <mission/com/SyrlinksHandler.h>
+#include <mission/com/VirtualChannelWithQueue.h>
 #include <mission/payload/PayloadPcduHandler.h>
 #include <mission/payload/RadiationSensorHandler.h>
 #include <mission/payload/payloadPcduDefinitions.h>
@@ -95,7 +97,6 @@ using gpio::Levels;
 #include <mission/tcs/Max31865Definitions.h>
 #include <mission/tcs/Max31865PT1000Handler.h>
 #include <mission/tcs/Tmp1075Handler.h>
-#include <mission/tmtc/VirtualChannelWithQueue.h>
 
 #include <sstream>
 
@@ -124,6 +125,7 @@ using gpio::Levels;
 
 ResetArgs RESET_ARGS_GNSS;
 std::atomic_bool LINK_STATE = CcsdsIpCoreHandler::LINK_DOWN;
+std::atomic_bool PTME_LOCKED = false;
 std::atomic_uint16_t I2C_FATAL_ERRORS = 0;
 
 void Factory::setStaticFrameworkObjectIds() {
@@ -516,6 +518,8 @@ void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF*
       new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT, debugGps);
   gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);
 
+  new HealthDevice(objects::GPS_0_HEALTH_DEV, objects::ACS_BOARD_ASS);
+  new HealthDevice(objects::GPS_1_HEALTH_DEV, objects::ACS_BOARD_ASS);
   ObjectFactory::createAcsBoardAssy(pwrSwitcher, assemblyChildren, gpsCtrl, gpioComIF);
 #endif /* OBSW_ADD_ACS_HANDLERS == 1 */
 }
@@ -751,10 +755,8 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
   gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_BUSY, gpio);
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC3, "PAPB VC3");
   gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_EMPTY, gpio);
-  // Initialise to low and then pull high to do a PTME reset, which puts the PTME in reset
-  // state. It will be put out of reset in the CCSDS handler initialize function.
   gpio = new GpiodRegularByLineName(q7s::gpioNames::PTME_RESETN, "PTME RESETN",
-                                    gpio::Direction::OUT, gpio::Levels::LOW);
+                                    gpio::Direction::OUT, gpio::Levels::HIGH);
   gpioCookiePtmeIp->addGpio(gpioIds::PTME_RESETN, gpio);
   gpioChecker(args.gpioComIF.addGpios(gpioCookiePtmeIp), "PTME PAPB VCs");
 
@@ -788,34 +790,42 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
 
   *args.ipCoreHandler =
       new CcsdsIpCoreHandler(objects::CCSDS_HANDLER, objects::CCSDS_PACKET_DISTRIBUTOR, *ptmeConfig,
-                             LINK_STATE, &args.gpioComIF, gpios);
+                             LINK_STATE, &args.gpioComIF, gpios, PTME_LOCKED);
   // This VC will receive all live TM
   auto* vcWithQueue =
       new VirtualChannelWithQueue(objects::PTME_VC0_LIVE_TM, ccsds::VC0, "PTME VC0 LIVE TM", *ptme,
                                   LINK_STATE, args.tmStore, 500);
   args.liveDestination = vcWithQueue;
-  new LiveTmTask(objects::LIVE_TM_TASK, args.pusFunnel, args.cfdpFunnel, *vcWithQueue);
+  auto* liveTask = new LiveTmTask(objects::LIVE_TM_TASK, args.pusFunnel, args.cfdpFunnel,
+                                  *vcWithQueue, PTME_LOCKED);
+  liveTask->connectModeTreeParent(satsystem::com::SUBSYSTEM);
 
   // Set up log store.
   auto* vc = new VirtualChannel(objects::PTME_VC1_LOG_TM, ccsds::VC1, "PTME VC1 LOG TM", *ptme,
                                 LINK_STATE);
   LogStores logStores(args.stores);
   // Core task which handles the LOG store and takes care of dumping it as TM using a VC directly
-  new PersistentLogTmStoreTask(objects::LOG_STORE_AND_TM_TASK, args.ipcStore, logStores, *vc,
-                               *SdCardManager::instance());
+  auto* logStore =
+      new PersistentLogTmStoreTask(objects::LOG_STORE_AND_TM_TASK, args.ipcStore, logStores, *vc,
+                                   *SdCardManager::instance(), PTME_LOCKED);
+  logStore->connectModeTreeParent(satsystem::com::SUBSYSTEM);
 
   vc = new VirtualChannel(objects::PTME_VC2_HK_TM, ccsds::VC2, "PTME VC2 HK TM", *ptme, LINK_STATE);
   // Core task which handles the HK store and takes care of dumping it as TM using a VC directly
-  new PersistentSingleTmStoreTask(objects::HK_STORE_AND_TM_TASK, args.ipcStore,
-                                  *args.stores.hkStore, *vc, persTmStore::DUMP_HK_STORE_DONE,
-                                  persTmStore::DUMP_HK_STORE_DONE, *SdCardManager::instance());
+  auto* hkStore = new PersistentSingleTmStoreTask(
+      objects::HK_STORE_AND_TM_TASK, args.ipcStore, *args.stores.hkStore, *vc,
+      persTmStore::DUMP_HK_STORE_DONE, persTmStore::DUMP_HK_STORE_DONE, *SdCardManager::instance(),
+      PTME_LOCKED);
+  hkStore->connectModeTreeParent(satsystem::com::SUBSYSTEM);
 
   vc = new VirtualChannel(objects::PTME_VC3_CFDP_TM, ccsds::VC3, "PTME VC3 CFDP TM", *ptme,
                           LINK_STATE);
   // Core task which handles the CFDP store and takes care of dumping it as TM using a VC directly
-  new PersistentSingleTmStoreTask(objects::CFDP_STORE_AND_TM_TASK, args.ipcStore,
-                                  *args.stores.cfdpStore, *vc, persTmStore::DUMP_CFDP_STORE_DONE,
-                                  persTmStore::DUMP_CFDP_CANCELLED, *SdCardManager::instance());
+  auto* cfdpTask = new PersistentSingleTmStoreTask(
+      objects::CFDP_STORE_AND_TM_TASK, args.ipcStore, *args.stores.cfdpStore, *vc,
+      persTmStore::DUMP_CFDP_STORE_DONE, persTmStore::DUMP_CFDP_CANCELLED,
+      *SdCardManager::instance(), PTME_LOCKED);
+  cfdpTask->connectModeTreeParent(satsystem::com::SUBSYSTEM);
 
   ReturnValue_t result = (*args.ipCoreHandler)->connectModeTreeParent(satsystem::com::SUBSYSTEM);
   if (result != returnvalue::OK) {

bsp_q7s/core/ObjectFactory.h

@@ -4,11 +4,11 @@
 #include <fsfw/returnvalues/returnvalue.h>
 #include <fsfw_hal/linux/spi/SpiComIF.h>
 #include <mission/com/CcsdsIpCoreHandler.h>
+#include <mission/com/PersistentLogTmStoreTask.h>
 #include <mission/genericFactory.h>
 #include <mission/system/objects/Stack5VHandler.h>
 #include <mission/tcs/HeaterHandler.h>
 #include <mission/tmtc/CfdpTmFunnel.h>
-#include <mission/tmtc/PersistentLogTmStoreTask.h>
 #include <mission/tmtc/PusTmFunnel.h>
 
 #include <atomic>
@@ -24,6 +24,7 @@ class AcsBoardAssembly;
 class GpioIF;
 
 extern std::atomic_uint16_t I2C_FATAL_ERRORS;
+extern std::atomic_bool PTME_LOCKED;
 
 namespace ObjectFactory {
 

bsp_q7s/core/scheduling.cpp

@@ -291,6 +291,14 @@ void scheduling::initTasks() {
   if (result != returnvalue::OK) {
     scheduling::printAddObjectError("STR_ASSY", objects::STR_ASSY);
   }
+  result = acsSysTask->addComponent(objects::GPS_0_HEALTH_DEV);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("GPS_0_HEALTH_DEV", objects::GPS_0_HEALTH_DEV);
+  }
+  result = acsSysTask->addComponent(objects::GPS_1_HEALTH_DEV);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("GPS_1_HEALTH_DEV", objects::GPS_1_HEALTH_DEV);
+  }
 
   PeriodicTaskIF* tcsSystemTask = factory->createPeriodicTask(
       "TCS_TASK", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc, &RR_SCHEDULING);

bsp_q7s/em/emObjectFactory.cpp

@@ -13,7 +13,7 @@
 #include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
 #include "devConf.h"
-#include "dummies/helpers.h"
+#include "dummies/helperFactory.h"
 #include "eive/objects.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 #include "linux/ObjectFactory.h"

common/config/eive/definitions.h

@@ -15,6 +15,9 @@ static constexpr char OBSW_VERSION_FILE_NAME[] = "obsw_version.txt";
 static constexpr char OBSW_PATH[] = "/usr/bin/eive-obsw";
 static constexpr char OBSW_VERSION_FILE_PATH[] = "/usr/share/eive-obsw/obsw_version.txt";
 
+// ISO8601 timestamp.
+static constexpr char FILE_DATE_FORMAT[] = "%FT%H%M%SZ";
+
 static constexpr uint16_t EIVE_PUS_APID = 0x65;
 static constexpr uint16_t EIVE_CFDP_APID = 0x66;
 static constexpr uint16_t EIVE_LOCAL_CFDP_ENTITY_ID = EIVE_CFDP_APID;

common/config/eive/objects.h

@@ -43,6 +43,8 @@ enum commonObjects : uint32_t {
   RW4 = 0x44120350,
   STAR_TRACKER = 0x44130001,
   GPS_CONTROLLER = 0x44130045,
+  GPS_0_HEALTH_DEV = 0x44130046,
+  GPS_1_HEALTH_DEV = 0x44130047,
 
   IMTQ_POLLING = 0x44140013,
   IMTQ_HANDLER = 0x44140014,

dummies/CMakeLists.txt

@@ -26,6 +26,6 @@ target_sources(
          CoreControllerDummy.cpp
          PlocMpsocDummy.cpp
          PlocSupervisorDummy.cpp
-         helpers.cpp
+         helperFactory.cpp
          MgmRm3100Dummy.cpp
          Tmp1075Dummy.cpp)

dummies/PcduHandlerDummy.cpp

@@ -2,8 +2,12 @@
 
 #include <mission/power/gsDefs.h>
 
+#include "mission/power/defs.h"
+
 PcduHandlerDummy::PcduHandlerDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
-    : DeviceHandlerBase(objectId, comif, comCookie), dummySwitcher(objectId, 18, 18, false) {}
+    : DeviceHandlerBase(objectId, comif, comCookie), dummySwitcher(objectId, 18, 18, false) {
+  switcherLock = MutexFactory::instance()->createMutex();
+}
 
 PcduHandlerDummy::~PcduHandlerDummy() {}
 
@@ -44,6 +48,17 @@ ReturnValue_t PcduHandlerDummy::initializeLocalDataPool(localpool::DataPool &loc
 }
 
 ReturnValue_t PcduHandlerDummy::sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) {
+  if (onOff == SWITCH_ON) {
+    triggerEvent(power::SWITCH_CMD_SENT, true, switchNr);
+  } else {
+    triggerEvent(power::SWITCH_CMD_SENT, false, switchNr);
+  }
+  {
+    MutexGuard mg(switcherLock);
+    // To simulate a real PCDU, remember the switch change to trigger a SWITCH_HAS_CHANGED event
+    // at a later stage.
+    switchChangeArray[switchNr] = true;
+  }
   return dummySwitcher.sendSwitchCommand(switchNr, onOff);
 }
 
@@ -60,3 +75,22 @@ ReturnValue_t PcduHandlerDummy::getFuseState(uint8_t fuseNr) const {
 }
 
 uint32_t PcduHandlerDummy::getSwitchDelayMs(void) const { return dummySwitcher.getSwitchDelayMs(); }
+
+void PcduHandlerDummy::performOperationHook() {
+  SwitcherBoolArray switcherChangeCopy{};
+  {
+    MutexGuard mg(switcherLock);
+    std::memcpy(switcherChangeCopy.data(), switchChangeArray.data(), switchChangeArray.size());
+  }
+  for (uint8_t idx = 0; idx < switcherChangeCopy.size(); idx++) {
+    if (switcherChangeCopy[idx]) {
+      if (dummySwitcher.getSwitchState(idx) == PowerSwitchIF::SWITCH_ON) {
+        triggerEvent(power::SWITCH_HAS_CHANGED, true, idx);
+      } else {
+        triggerEvent(power::SWITCH_HAS_CHANGED, false, idx);
+      }
+      MutexGuard mg(switcherLock);
+      switchChangeArray[idx] = false;
+    }
+  }
+}

dummies/PcduHandlerDummy.h

@@ -15,8 +15,12 @@ class PcduHandlerDummy : public DeviceHandlerBase, public PowerSwitchIF {
   virtual ~PcduHandlerDummy();
 
  protected:
+  MutexIF *switcherLock;
   DummyPowerSwitcher dummySwitcher;
+  using SwitcherBoolArray = std::array<bool, 18>;
 
+  SwitcherBoolArray switchChangeArray{};
+  void performOperationHook() override;
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;

dummies/helperFactory.cpp

@@ -1,4 +1,4 @@
-#include "helpers.h"
+#include "helperFactory.h"
 
 #include <dummies/AcuDummy.h>
 #include <dummies/BpxDummy.h>
@@ -24,11 +24,12 @@
 #include <dummies/StarTrackerDummy.h>
 #include <dummies/SusDummy.h>
 #include <dummies/SyrlinksDummy.h>
+#include <fsfw/devicehandlers/HealthDevice.h>
 #include <fsfw_hal/common/gpio/GpioIF.h>
 #include <mission/power/gsDefs.h>
 #include <mission/system/acs/ImtqAssembly.h>
+#include <mission/system/acs/StrAssembly.h>
 #include <mission/system/objects/CamSwitcher.h>
-#include <mission/system/objects/StrAssembly.h>
 #include <mission/system/objects/TcsBoardAssembly.h>
 
 #include "TemperatureSensorInserter.h"
@@ -98,6 +99,8 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
         new GyroAdisDummy(objects::GYRO_2_ADIS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
     assemblyDhbs[7] =
         new GyroL3GD20Dummy(objects::GYRO_3_L3G_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    new HealthDevice(objects::GPS_0_HEALTH_DEV, objects::ACS_BOARD_ASS);
+    new HealthDevice(objects::GPS_1_HEALTH_DEV, objects::ACS_BOARD_ASS);
     auto* gpsCtrl = new GpsCtrlDummy(objects::GPS_CONTROLLER);
     ObjectFactory::createAcsBoardAssy(pwrSwitcher, assemblyDhbs, gpsCtrl, gpioIF);
   }

generators/bsp_hosted_events.csv

@@ -203,6 +203,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12801;0x3201;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;No description;mission/system/acs/AcsBoardAssembly.h
 12802;0x3202;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;No description;mission/system/acs/AcsBoardAssembly.h
 12803;0x3203;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/acs/AcsBoardAssembly.h
+12804;0x3204;DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY;MEDIUM;This is triggered when the assembly would have normally switched the board side, but the GPS device of the other side was marked faulty. P1: Current submode.;mission/system/acs/AcsBoardAssembly.h
 12900;0x3264;TRANSITION_OTHER_SIDE_FAILED;HIGH;No description;mission/system/acs/SusAssembly.h
 12901;0x3265;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;No description;mission/system/acs/SusAssembly.h
 12902;0x3266;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;No description;mission/system/acs/SusAssembly.h

generators/bsp_hosted_objects.csv

@@ -30,6 +30,8 @@
 0x44120350;RW4
 0x44130001;STAR_TRACKER
 0x44130045;GPS_CONTROLLER
+0x44130046;GPS_0_HEALTH_DEV
+0x44130047;GPS_1_HEALTH_DEV
 0x44140013;IMTQ_POLLING
 0x44140014;IMTQ_HANDLER
 0x442000A1;PCDU_HANDLER

generators/bsp_hosted_returnvalues.csv

@@ -190,8 +190,8 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x2207;TMF_AllDeleted;No description;7;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
 0x2208;TMF_InvalidData;No description;8;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
 0x2209;TMF_NotReady;No description;9;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2401;MT_TooDetailedRequest;No description;1;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2402;MT_TooGeneralRequest;No description;2;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2401;MT_NoPacketFound;No description;1;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/DleParser.h
+0x2402;MT_PossiblePacketLoss;No description;2;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/DleParser.h
 0x2403;MT_NoMatch;No description;3;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
 0x2404;MT_Full;No description;4;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
 0x2405;MT_NewNodeCreated;No description;5;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
@@ -371,8 +371,8 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x3e03;HKM_PeriodicHelperInvalid;No description;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
 0x3e04;HKM_PoolobjectNotFound;No description;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
 0x3e05;HKM_DatasetNotFound;No description;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3f01;DLEE_NoPacketFound;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleParser.h
-0x3f02;DLEE_PossiblePacketLoss;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleParser.h
+0x3f01;DLEE_StreamTooShort;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x3f02;DLEE_DecodingError;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
 0x4201;PUS11_InvalidTypeTimeWindow;No description;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 0x4202;PUS11_InvalidTimeWindow;No description;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 0x4203;PUS11_TimeshiftingNotPossible;No description;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
@@ -402,9 +402,9 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
 0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
 0x4406;UXOS_PcloseCallError;No description;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4500;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
-0x4501;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
-0x4502;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
+0x4500;HSPI_HalTimeoutRetval;No description;0;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
+0x4501;HSPI_HalBusyRetval;No description;1;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
+0x4502;HSPI_HalErrorRetval;No description;2;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
 0x4601;HURT_UartReadFailure;No description;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
 0x4602;HURT_UartReadSizeMissmatch;No description;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
 0x4603;HURT_UartRxBufferTooSmall;No description;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h

generators/bsp_q7s_events.csv

@@ -203,6 +203,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12801;0x3201;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;No description;mission/system/acs/AcsBoardAssembly.h
 12802;0x3202;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;No description;mission/system/acs/AcsBoardAssembly.h
 12803;0x3203;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/acs/AcsBoardAssembly.h
+12804;0x3204;DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY;MEDIUM;This is triggered when the assembly would have normally switched the board side, but the GPS device of the other side was marked faulty. P1: Current submode.;mission/system/acs/AcsBoardAssembly.h
 12900;0x3264;TRANSITION_OTHER_SIDE_FAILED;HIGH;No description;mission/system/acs/SusAssembly.h
 12901;0x3265;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;No description;mission/system/acs/SusAssembly.h
 12902;0x3266;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;No description;mission/system/acs/SusAssembly.h

generators/bsp_q7s_objects.csv

@@ -29,6 +29,8 @@
 0x44120350;RW4
 0x44130001;STAR_TRACKER
 0x44130045;GPS_CONTROLLER
+0x44130046;GPS_0_HEALTH_DEV
+0x44130047;GPS_1_HEALTH_DEV
 0x44140013;IMTQ_POLLING
 0x44140014;IMTQ_HANDLER
 0x442000A1;PCDU_HANDLER

generators/bsp_q7s_returnvalues.csv

@@ -190,8 +190,8 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x2207;TMF_AllDeleted;No description;7;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
 0x2208;TMF_InvalidData;No description;8;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
 0x2209;TMF_NotReady;No description;9;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2401;MT_TooDetailedRequest;No description;1;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2402;MT_TooGeneralRequest;No description;2;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2401;MT_NoPacketFound;No description;1;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/DleParser.h
+0x2402;MT_PossiblePacketLoss;No description;2;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/DleParser.h
 0x2403;MT_NoMatch;No description;3;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
 0x2404;MT_Full;No description;4;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
 0x2405;MT_NewNodeCreated;No description;5;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
@@ -371,8 +371,8 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x3e03;HKM_PeriodicHelperInvalid;No description;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
 0x3e04;HKM_PoolobjectNotFound;No description;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
 0x3e05;HKM_DatasetNotFound;No description;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3f01;DLEE_NoPacketFound;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleParser.h
-0x3f02;DLEE_PossiblePacketLoss;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleParser.h
+0x3f01;DLEE_StreamTooShort;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x3f02;DLEE_DecodingError;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
 0x4201;PUS11_InvalidTypeTimeWindow;No description;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 0x4202;PUS11_InvalidTimeWindow;No description;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 0x4203;PUS11_TimeshiftingNotPossible;No description;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
@@ -402,9 +402,9 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
 0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
 0x4406;UXOS_PcloseCallError;No description;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4500;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
-0x4501;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
-0x4502;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
+0x4500;HSPI_HalTimeoutRetval;No description;0;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
+0x4501;HSPI_HalBusyRetval;No description;1;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
+0x4502;HSPI_HalErrorRetval;No description;2;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
 0x4601;HURT_UartReadFailure;No description;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
 0x4602;HURT_UartReadSizeMissmatch;No description;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
 0x4603;HURT_UartRxBufferTooSmall;No description;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
@@ -492,10 +492,9 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x58a3;SUSS_ExecutionFailed;Command execution failed;163;SUS_HANDLER;mission/acs/RwHandler.h
 0x58a4;SUSS_CrcError;Reaction wheel reply has invalid crc;164;SUS_HANDLER;mission/acs/RwHandler.h
 0x58a5;SUSS_ValueNotRead;No description;165;SUS_HANDLER;mission/acs/RwHandler.h
-0x5900;IPCI_NoReplyAvailable;No description;0;CCSDS_IP_CORE_BRIDGE;linux/acs/ImtqPollingTask.h
-0x5901;IPCI_NoPacketFound;No description;1;CCSDS_IP_CORE_BRIDGE;linux/com/SyrlinksComHandler.h
 0x59a0;IPCI_PapbBusy;No description;160;CCSDS_IP_CORE_BRIDGE;linux/ipcore/PapbVcInterface.h
 0x5aa0;PTME_UnknownVcId;No description;160;PTME;linux/ipcore/Ptme.h
+0x5c00;STRHLP_NoReplyAvailable;No description;0;STR_HELPER;linux/acs/ImtqPollingTask.h
 0x5c01;STRHLP_SdNotMounted;SD card specified in path string not mounted;1;STR_HELPER;linux/acs/StrComHandler.h
 0x5c02;STRHLP_FileNotExists;Specified file does not exist on filesystem;2;STR_HELPER;linux/acs/StrComHandler.h
 0x5c03;STRHLP_PathNotExists;Specified path does not exist;3;STR_HELPER;linux/acs/StrComHandler.h
@@ -541,13 +540,13 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NvmParameterBase.h
 0x64a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;160;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
 0x64a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;161;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
-0x6502;PLMPHLP_InvalidCrc;No description;2;PLOC_MPSOC_HELPER;linux/payload/ScexHelper.h
 0x65a0;PLMPHLP_FileClosedAccidentally;File accidentally close;160;PLOC_MPSOC_HELPER;linux/payload/PlocMpsocHelper.h
 0x66a0;SADPL_CommandNotSupported;No description;160;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
 0x66a1;SADPL_DeploymentAlreadyExecuting;No description;161;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
 0x66a2;SADPL_MainSwitchTimeoutFailure;No description;162;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
 0x66a3;SADPL_SwitchingDeplSa1Failed;No description;163;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
 0x66a4;SADPL_SwitchingDeplSa2Failed;No description;164;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x6702;MPSOCRTVIF_InvalidCrc;No description;2;MPSOC_RETURN_VALUES_IF;linux/payload/ScexHelper.h
 0x67a0;MPSOCRTVIF_CrcFailure;Space Packet received from PLOC has invalid CRC;160;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
 0x67a1;MPSOCRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC;161;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
 0x67a2;MPSOCRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC;162;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
@@ -558,6 +557,7 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x67a7;MPSOCRTVIF_MpsocFilenameTooLong;Filename of MPSoC file is to long (max. 256 bytes);167;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
 0x67a8;MPSOCRTVIF_InvalidParameter;Command has invalid parameter;168;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
 0x67a9;MPSOCRTVIF_NameTooLong;Received command has file string with invalid length;169;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
+0x6801;SPVRTVIF_NoPacketFound;No description;1;SUPV_RETURN_VALUES_IF;linux/com/SyrlinksComHandler.h
 0x68a0;SPVRTVIF_CrcFailure;Space Packet received from PLOC supervisor has invalid CRC;160;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
 0x68a1;SPVRTVIF_InvalidServiceId;No description;161;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
 0x68a2;SPVRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC supervisor;162;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 283 translations.
+ * @brief    Auto-generated event translation file. Contains 284 translations.
  * @details
- * Generated on: 2023-03-28 22:20:01
+ * Generated on: 2023-04-01 15:26:43
  */
 #include "translateEvents.h"
 
@@ -209,6 +209,7 @@ const char *TRANSITION_OTHER_SIDE_FAILED_STRING = "TRANSITION_OTHER_SIDE_FAILED"
 const char *NOT_ENOUGH_DEVICES_DUAL_MODE_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE";
 const char *POWER_STATE_MACHINE_TIMEOUT_STRING = "POWER_STATE_MACHINE_TIMEOUT";
 const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING = "SIDE_SWITCH_TRANSITION_NOT_ALLOWED";
+const char *DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY_STRING = "DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY";
 const char *TRANSITION_OTHER_SIDE_FAILED_12900_STRING = "TRANSITION_OTHER_SIDE_FAILED_12900";
 const char *NOT_ENOUGH_DEVICES_DUAL_MODE_12901_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE_12901";
 const char *POWER_STATE_MACHINE_TIMEOUT_12902_STRING = "POWER_STATE_MACHINE_TIMEOUT_12902";
@@ -699,6 +700,8 @@ const char *translateEvents(Event event) {
       return POWER_STATE_MACHINE_TIMEOUT_STRING;
     case (12803):
       return SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING;
+    case (12804):
+      return DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY_STRING;
     case (12900):
       return TRANSITION_OTHER_SIDE_FAILED_12900_STRING;
     case (12901):

generators/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 173 translations.
- * Generated on: 2023-03-28 22:20:01
+ * Contains 175 translations.
+ * Generated on: 2023-04-01 15:26:43
  */
 #include "translateObjects.h"
 
@@ -37,6 +37,8 @@ const char *GYRO_3_L3G_HANDLER_STRING = "GYRO_3_L3G_HANDLER";
 const char *RW4_STRING = "RW4";
 const char *STAR_TRACKER_STRING = "STAR_TRACKER";
 const char *GPS_CONTROLLER_STRING = "GPS_CONTROLLER";
+const char *GPS_0_HEALTH_DEV_STRING = "GPS_0_HEALTH_DEV";
+const char *GPS_1_HEALTH_DEV_STRING = "GPS_1_HEALTH_DEV";
 const char *IMTQ_POLLING_STRING = "IMTQ_POLLING";
 const char *IMTQ_HANDLER_STRING = "IMTQ_HANDLER";
 const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
@@ -244,6 +246,10 @@ const char *translateObject(object_id_t object) {
       return STAR_TRACKER_STRING;
     case 0x44130045:
       return GPS_CONTROLLER_STRING;
+    case 0x44130046:
+      return GPS_0_HEALTH_DEV_STRING;
+    case 0x44130047:
+      return GPS_1_HEALTH_DEV_STRING;
     case 0x44140013:
       return IMTQ_POLLING_STRING;
     case 0x44140014:

linux/acs/GpsHyperionLinuxController.cpp

@@ -99,6 +99,7 @@ void GpsHyperionLinuxController::setResetPinTriggerFunction(gpioResetFunction_t
 ReturnValue_t GpsHyperionLinuxController::performOperation(uint8_t opCode) {
   handleQueue();
   poolManager.performHkOperation();
+
   while (true) {
 #if OBSW_THREAD_TRACING == 1
     trace::threadTrace(opCounter, "GPS CTRL");

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 283 translations.
+ * @brief    Auto-generated event translation file. Contains 284 translations.
  * @details
- * Generated on: 2023-03-28 22:20:01
+ * Generated on: 2023-04-01 15:26:43
  */
 #include "translateEvents.h"
 
@@ -209,6 +209,8 @@ const char *TRANSITION_OTHER_SIDE_FAILED_STRING = "TRANSITION_OTHER_SIDE_FAILED"
 const char *NOT_ENOUGH_DEVICES_DUAL_MODE_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE";
 const char *POWER_STATE_MACHINE_TIMEOUT_STRING = "POWER_STATE_MACHINE_TIMEOUT";
 const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING = "SIDE_SWITCH_TRANSITION_NOT_ALLOWED";
+const char *DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY_STRING =
+    "DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY";
 const char *TRANSITION_OTHER_SIDE_FAILED_12900_STRING = "TRANSITION_OTHER_SIDE_FAILED_12900";
 const char *NOT_ENOUGH_DEVICES_DUAL_MODE_12901_STRING = "NOT_ENOUGH_DEVICES_DUAL_MODE_12901";
 const char *POWER_STATE_MACHINE_TIMEOUT_12902_STRING = "POWER_STATE_MACHINE_TIMEOUT_12902";
@@ -700,6 +702,8 @@ const char *translateEvents(Event event) {
       return POWER_STATE_MACHINE_TIMEOUT_STRING;
     case (12803):
       return SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING;
+    case (12804):
+      return DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY_STRING;
     case (12900):
       return TRANSITION_OTHER_SIDE_FAILED_12900_STRING;
     case (12901):

linux/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 173 translations.
- * Generated on: 2023-03-28 22:20:01
+ * Contains 175 translations.
+ * Generated on: 2023-04-01 15:26:43
  */
 #include "translateObjects.h"
 
@@ -37,6 +37,8 @@ const char *GYRO_3_L3G_HANDLER_STRING = "GYRO_3_L3G_HANDLER";
 const char *RW4_STRING = "RW4";
 const char *STAR_TRACKER_STRING = "STAR_TRACKER";
 const char *GPS_CONTROLLER_STRING = "GPS_CONTROLLER";
+const char *GPS_0_HEALTH_DEV_STRING = "GPS_0_HEALTH_DEV";
+const char *GPS_1_HEALTH_DEV_STRING = "GPS_1_HEALTH_DEV";
 const char *IMTQ_POLLING_STRING = "IMTQ_POLLING";
 const char *IMTQ_HANDLER_STRING = "IMTQ_HANDLER";
 const char *PCDU_HANDLER_STRING = "PCDU_HANDLER";
@@ -244,6 +246,10 @@ const char *translateObject(object_id_t object) {
       return STAR_TRACKER_STRING;
     case 0x44130045:
       return GPS_CONTROLLER_STRING;
+    case 0x44130046:
+      return GPS_0_HEALTH_DEV_STRING;
+    case 0x44130047:
+      return GPS_1_HEALTH_DEV_STRING;
     case 0x44140013:
       return IMTQ_POLLING_STRING;
     case 0x44140014:

linux/ipcore/PapbVcInterface.cpp

@@ -2,6 +2,7 @@
 #include <linux/ipcore/PapbVcInterface.h>
 #include <unistd.h>
 
+#include <cstring>
 #include <ctime>
 
 #include "fsfw/serviceinterface/ServiceInterface.h"
@@ -18,29 +19,63 @@ PapbVcInterface::~PapbVcInterface() {}
 
 ReturnValue_t PapbVcInterface::initialize() {
   UioMapper uioMapper(uioFile, mapNum);
-  uint32_t* baseReg;
-  ReturnValue_t result = uioMapper.getMappedAdress(&baseReg, UioMapper::Permissions::WRITE_ONLY);
+  ReturnValue_t result = uioMapper.getMappedAdress(const_cast<uint32_t**>(&vcBaseReg),
+                                                   UioMapper::Permissions::WRITE_ONLY);
   if (result != returnvalue::OK) {
     return result;
   }
-  vcBaseReg = baseReg;
   return returnvalue::OK;
 }
 
 ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
-  if (pollPapbBusySignal(0) == returnvalue::OK) {
-    startPacketTransfer();
+  // There are no packets smaller than 4, this is considered a configuration error.
+  if (size < 4) {
+    return returnvalue::FAILED;
+  }
+  if (pollInterfaceReadiness(0, true) == returnvalue::OK) {
+    startPacketTransfer(ByteWidthCfg::ONE);
   } else {
     return DirectTmSinkIF::IS_BUSY;
   }
+  // TODO: This should work but does not.. :(
+  //  size_t idx = 0;
+  //  while (idx < size) {
+  //
+  //    nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
+  //    if ((size - idx) < 4) {
+  //      *vcBaseReg = CONFIG_DATA_INPUT | (size - idx - 1);
+  //      usleep(1);
+  //    }
+  //    if (pollPapbBusySignal(2) == returnvalue::OK) {
+  //      //      vcBaseReg + DATA_REG_OFFSET + 3 = static_cast<uint8_t>(data + idx);
+  //      //      vcBaseReg + DATA_REG_OFFSET + 2 = static_cast<uint8_t>(data + idx + 1);
+  //      //      vcBaseReg + DATA_REG_OFFSET + 1 = static_cast<uint8_t>(data + idx + 2);
+  //      //      vcBaseReg + DATA_REG_OFFSET = static_cast<uint8_t>(data + idx + 3);
+  //
+  //      // std::memcpy((vcBaseReg + DATA_REG_OFFSET), data + idx , nextWriteSize);
+  //      *(vcBaseReg + DATA_REG_OFFSET) = *reinterpret_cast<const uint32_t*>(data + idx);
+  //      //uint8_t* byteReg = reinterpret_cast<uint8_t*>(vcBaseReg + DATA_REG_OFFSET);
+  //
+  //      //byteReg[0] = data[idx];
+  //      //byteReg[1] = data[idx];
+  //    } else {
+  //      abortPacketTransfer();
+  //      return returnvalue::FAILED;
+  //    }
+  //    // TODO: Change this after the bugfix. Right now, the PAPB ignores the content of the byte
+  //    // width configuration.5
+  //    // It's okay to increment by a larger amount for the last segment here, loop will be over
+  //    // in any case.
+  //    idx += 4;
+  //  }
   for (size_t idx = 0; idx < size; idx++) {
     // This delay is super-important, DO NOT REMOVE!
-    // Polling the GPIO too often can mess up the scheduler.
+    // Polling the GPIO or the config register too often messes up the scheduler.
     // TODO: Maybe this should not be done like this. It would be better if there was a custom
     // FPGA module which can accept packets and then takes care of dumping that packet into
     // the PTME. DMA would be an ideal solution for this.
     nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
-    if (pollPapbBusySignal(2) == returnvalue::OK) {
+    if (pollInterfaceReadiness(2, false) == returnvalue::OK) {
       *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[idx]);
     } else {
       abortPacketTransfer();
@@ -48,7 +83,7 @@ ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
     }
   }
   nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
-  if (pollPapbBusySignal(2) == returnvalue::OK) {
+  if (pollInterfaceReadiness(2, false) == returnvalue::OK) {
     completePacketTransfer();
   } else {
     abortPacketTransfer();
@@ -57,27 +92,29 @@ ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
   return returnvalue::OK;
 }
 
-void PapbVcInterface::startPacketTransfer() { *vcBaseReg = CONFIG_START; }
+void PapbVcInterface::startPacketTransfer(ByteWidthCfg initWidth) {
+  *vcBaseReg = CONFIG_DATA_INPUT | initWidth;
+}
 
 void PapbVcInterface::completePacketTransfer() { *vcBaseReg = CONFIG_END; }
 
-ReturnValue_t PapbVcInterface::pollPapbBusySignal(uint32_t maxPollRetries) const {
-  gpio::Levels papbBusyState = gpio::Levels::LOW;
-  ReturnValue_t result;
+ReturnValue_t PapbVcInterface::pollInterfaceReadiness(uint32_t maxPollRetries,
+                                                      bool checkReadyState) const {
   uint32_t busyIdx = 0;
-  nextDelay.tv_nsec = 0;
+  nextDelay.tv_nsec = FIRST_DELAY_PAPB_POLLING_NS;
 
   while (true) {
-    /** Check if PAPB interface is ready to receive data */
-    result = gpioComIF->readGpio(papbBusyId, papbBusyState);
-    if (result != returnvalue::OK) {
-      sif::warning << "PapbVcInterface::pollPapbBusySignal: Failed to read papb busy signal"
-                   << std::endl;
-      return returnvalue::FAILED;
-    }
-    if (papbBusyState == gpio::Levels::HIGH) {
+    // 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.
+    uint32_t reg = *vcBaseReg;
+    bool busy = (reg >> 5) & 0b1;
+    bool ready = (reg >> 6) & 0b1;
+    if (not busy) {
       return returnvalue::OK;
     }
+    if (checkReadyState and not ready) {
+      return PAPB_BUSY;
+    }
 
     busyIdx++;
     if (busyIdx >= maxPollRetries) {
@@ -87,9 +124,7 @@ ReturnValue_t PapbVcInterface::pollPapbBusySignal(uint32_t maxPollRetries) const
     // Ignore signal handling here for now.
     nanosleep(&nextDelay, &remDelay);
     // Adaptive delay.
-    if (nextDelay.tv_nsec == 0) {
-      nextDelay.tv_nsec = FIRST_NON_NULL_DELAY_NS;
-    } else if (nextDelay.tv_nsec * 2 <= MAX_DELAY_PAPB_POLLING_NS) {
+    if (nextDelay.tv_nsec * 2 <= MAX_DELAY_PAPB_POLLING_NS) {
       nextDelay.tv_nsec *= 2;
     }
   }
@@ -116,7 +151,7 @@ void PapbVcInterface::isVcInterfaceBufferEmpty() {
   return;
 }
 
-bool PapbVcInterface::isBusy() const { return pollPapbBusySignal(0) == PAPB_BUSY; }
+bool PapbVcInterface::isBusy() const { return pollInterfaceReadiness(0, true) == PAPB_BUSY; }
 
 void PapbVcInterface::cancelTransfer() { abortPacketTransfer(); }
 

linux/ipcore/PapbVcInterface.h

@@ -5,6 +5,8 @@
 #include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
 #include <linux/ipcore/VirtualChannelIF.h>
 
+#include <atomic>
+
 #include "OBSWConfig.h"
 #include "fsfw/returnvalues/returnvalue.h"
 
@@ -50,13 +52,14 @@ class PapbVcInterface : public VirtualChannelIF {
 
   static const ReturnValue_t PAPB_BUSY = MAKE_RETURN_CODE(0xA0);
 
+  enum ByteWidthCfg : uint32_t { ONE = 0b00, TWO = 0b01, THREE = 0b10, FOUR = 0b11 };
   /**
    * Configuration bits:
    * bit[1:0]: Size of data (1,2,3 or 4 bytes). 1 Byte <=> b00
    * bit[2]: Set this bit to 1 to abort a transferred packet
    * bit[3]: Signals to VcInterface the start of a new telemetry packet
    */
-  static constexpr uint32_t CONFIG_START = 0b00001000;
+  static constexpr uint32_t CONFIG_DATA_INPUT = 0b00001000;
 
   /**
    * Abort a transferred packet.
@@ -76,7 +79,7 @@ class PapbVcInterface : public VirtualChannelIF {
    */
   static const int DATA_REG_OFFSET = 256;
 
-  static constexpr long int FIRST_NON_NULL_DELAY_NS = 10;
+  static constexpr long int FIRST_DELAY_PAPB_POLLING_NS = 10;
   static constexpr long int MAX_DELAY_PAPB_POLLING_NS = 40;
 
   LinuxLibgpioIF* gpioComIF = nullptr;
@@ -89,7 +92,7 @@ class PapbVcInterface : public VirtualChannelIF {
   std::string uioFile;
   int mapNum = 0;
   mutable struct timespec nextDelay = {.tv_sec = 0, .tv_nsec = 0};
-  const struct timespec BETWEEN_POLL_DELAY = {.tv_sec = 0, .tv_nsec = 5};
+  const struct timespec BETWEEN_POLL_DELAY = {.tv_sec = 0, .tv_nsec = 10};
   mutable struct timespec remDelay;
 
   volatile uint32_t* vcBaseReg = nullptr;
@@ -100,7 +103,7 @@ class PapbVcInterface : public VirtualChannelIF {
    * @brief   This function sends the config byte to the virtual channel of the PTME IP Core
    *          to initiate a packet transfer.
    */
-  void startPacketTransfer();
+  void startPacketTransfer(ByteWidthCfg initWidth);
 
   void abortPacketTransfer();
 
@@ -117,7 +120,7 @@ class PapbVcInterface : public VirtualChannelIF {
    *
    * @return  returnvalue::OK when ready to receive data else PAPB_BUSY.
    */
-  inline ReturnValue_t pollPapbBusySignal(uint32_t maxPollRetries) const;
+  inline ReturnValue_t pollInterfaceReadiness(uint32_t maxPollRetries, bool checkReadyState) const;
 
   /**
    * @brief   This function can be used for debugging to check whether there are packets in

mission/acs/GyrAdis1650XHandler.cpp

@@ -87,12 +87,11 @@ ReturnValue_t GyrAdis1650XHandler::scanForReply(const uint8_t *start, size_t rem
       getMode() == _MODE_POWER_DOWN) {
     return IGNORE_FULL_PACKET;
   }
+  *foundLen = remainingSize;
   if (remainingSize != sizeof(acs::Adis1650XReply)) {
-    *foundLen = remainingSize;
     return returnvalue::FAILED;
   }
   *foundId = adis1650x::REPLY;
-  *foundLen = remainingSize;
   if (internalState == InternalState::SHUTDOWN) {
     commandExecuted = true;
   }

mission/acs/GyrL3gCustomHandler.cpp

@@ -99,12 +99,11 @@ ReturnValue_t GyrL3gCustomHandler::scanForReply(const uint8_t *start, size_t len
   if (getMode() == _MODE_WAIT_OFF or getMode() == _MODE_WAIT_ON or getMode() == _MODE_POWER_DOWN) {
     return IGNORE_FULL_PACKET;
   }
+  *foundLen = len;
   if (len != sizeof(acs::GyroL3gReply)) {
-    *foundLen = len;
     return returnvalue::FAILED;
   }
-  *foundId = l3gd20h::REPLY;
-  *foundLen = len;
+  *foundId = adis1650x::REPLY;
   if (internalState == InternalState::SHUTDOWN) {
     commandExecuted = true;
   }

mission/acs/str/StarTrackerHandler.cpp

@@ -213,6 +213,8 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
     default:
       break;
   }
+  // In case the JSON has changed, reinitiate the next parameter set to update.
+  reinitNextSetParam = true;
   return DeviceHandlerBase::executeAction(actionId, commandedBy, data, size);
 }
 
@@ -273,6 +275,7 @@ void StarTrackerHandler::doShutDown() {
   startupState = StartupState::IDLE;
   bootState = FwBootState::NONE;
   solutionSet.setReportingEnabled(false);
+  reinitNextSetParam = false;
   setMode(_MODE_POWER_DOWN);
 }
 
@@ -313,6 +316,8 @@ ReturnValue_t StarTrackerHandler::buildTransitionDeviceCommand(DeviceCommandId_t
         if (bootCountdown.isBusy()) {
           return NOTHING_TO_SEND;
         }
+        // Was already done.
+        reinitNextSetParam = false;
         bootState = FwBootState::REQ_VERSION;
       }
       switch (bootState) {
@@ -461,7 +466,8 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
       return returnvalue::OK;
     }
     case (startracker::SUBSCRIPTION): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.subscription);
+      result =
+          prepareParamCommand(commandData, commandDataLen, jcfgs.subscription, reinitNextSetParam);
       return returnvalue::OK;
     }
     case (startracker::REQ_SOLUTION): {
@@ -477,55 +483,60 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
       return returnvalue::OK;
     }
     case (startracker::LIMITS): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.limits);
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.limits, reinitNextSetParam);
       return result;
     }
     case (startracker::MOUNTING): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.mounting);
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.mounting, reinitNextSetParam);
       return result;
     }
     case (startracker::IMAGE_PROCESSOR): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.imageProcessor);
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.imageProcessor,
+                                   reinitNextSetParam);
       return result;
     }
     case (startracker::CAMERA): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.camera);
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.camera, reinitNextSetParam);
       return result;
     }
     case (startracker::CENTROIDING): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.centroiding);
+      result =
+          prepareParamCommand(commandData, commandDataLen, jcfgs.centroiding, reinitNextSetParam);
       return result;
     }
     case (startracker::LISA): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.lisa);
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.lisa, reinitNextSetParam);
       return result;
     }
     case (startracker::MATCHING): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.matching);
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.matching, reinitNextSetParam);
       return result;
     }
     case (startracker::VALIDATION): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.validation);
+      result =
+          prepareParamCommand(commandData, commandDataLen, jcfgs.validation, reinitNextSetParam);
       return result;
     }
     case (startracker::ALGO): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.algo);
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.algo, reinitNextSetParam);
       return result;
     }
     case (startracker::TRACKING): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.tracking);
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.tracking, reinitNextSetParam);
       return result;
     }
     case (startracker::LOGLEVEL): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.logLevel);
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.logLevel, reinitNextSetParam);
       return result;
     }
     case (startracker::LOGSUBSCRIPTION): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.logSubscription);
+      result = prepareParamCommand(commandData, commandDataLen, jcfgs.logSubscription,
+                                   reinitNextSetParam);
       return result;
     }
     case (startracker::DEBUG_CAMERA): {
-      result = prepareParamCommand(commandData, commandDataLen, jcfgs.debugCamera);
+      result =
+          prepareParamCommand(commandData, commandDataLen, jcfgs.debugCamera, reinitNextSetParam);
       return result;
     }
     case (startracker::CHECKSUM): {
@@ -1690,12 +1701,19 @@ void StarTrackerHandler::prepareHistogramRequest() {
 
 ReturnValue_t StarTrackerHandler::prepareParamCommand(const uint8_t* commandData,
                                                       size_t commandDataLen,
-                                                      ArcsecJsonParamBase& paramSet) {
+                                                      ArcsecJsonParamBase& paramSet,
+                                                      bool reinitSet) {
   // Stopwatch watch;
   ReturnValue_t result = returnvalue::OK;
   if (commandDataLen > MAX_PATH_SIZE) {
     return FILE_PATH_TOO_LONG;
   }
+  if (reinitSet) {
+    result = paramSet.init(paramJsonFile);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+  }
 
   result = paramSet.create(commandBuffer);
   if (result != returnvalue::OK) {

mission/acs/str/StarTrackerHandler.h

@@ -287,6 +287,8 @@ class StarTrackerHandler : public DeviceHandlerBase {
 
   InternalState internalState = InternalState::IDLE;
 
+  bool reinitNextSetParam = false;
+
   bool strHelperHandlingSpecialRequest = false;
 
   const power::Switch_t powerSwitch = power::NO_SWITCH;
@@ -409,7 +411,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
    * @return  returnvalue::OK if successful, otherwise error return Value
    */
   ReturnValue_t prepareParamCommand(const uint8_t* commandData, size_t commandDataLen,
-                                    ArcsecJsonParamBase& paramSet);
+                                    ArcsecJsonParamBase& paramSet, bool reinitSet);
 
   /**
    * @brief   The following function will fill the command buffer with the command to request

mission/com/CMakeLists.txt

@@ -1,2 +1,11 @@
-target_sources(${LIB_EIVE_MISSION} PRIVATE SyrlinksHandler.cpp
-                                           CcsdsIpCoreHandler.cpp)
+target_sources(
+  ${LIB_EIVE_MISSION}
+  PRIVATE SyrlinksHandler.cpp
+          CcsdsIpCoreHandler.cpp
+          LiveTmTask.cpp
+          PersistentLogTmStoreTask.cpp
+          TmStoreTaskBase.cpp
+          VirtualChannel.cpp
+          VirtualChannelWithQueue.cpp
+          PersistentSingleTmStoreTask.cpp
+          LiveTmTask.cpp)

mission/com/CcsdsIpCoreHandler.cpp

@@ -15,9 +15,11 @@
 
 CcsdsIpCoreHandler::CcsdsIpCoreHandler(object_id_t objectId, object_id_t tcDestination,
                                        PtmeConfig& ptmeConfig, std::atomic_bool& linkState,
-                                       GpioIF* gpioIF, PtmeGpios gpioIds)
+                                       GpioIF* gpioIF, PtmeGpios gpioIds,
+                                       std::atomic_bool& ptmeLocked)
     : SystemObject(objectId),
       linkState(linkState),
+      ptmeLocked(ptmeLocked),
       tcDestination(tcDestination),
       parameterHelper(this),
       actionHelper(this, nullptr),
@@ -29,12 +31,14 @@ CcsdsIpCoreHandler::CcsdsIpCoreHandler(object_id_t objectId, object_id_t tcDesti
   auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
   eventQueue =
       QueueFactory::instance()->createMessageQueue(10, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
+  ptmeLocked = true;
 }
 
 CcsdsIpCoreHandler::~CcsdsIpCoreHandler() = default;
 
 ReturnValue_t CcsdsIpCoreHandler::performOperation(uint8_t operationCode) {
   readCommandQueue();
+  performPtmeUpdateWhenApplicable();
   return returnvalue::OK;
 }
 
@@ -76,6 +80,8 @@ ReturnValue_t CcsdsIpCoreHandler::initialize() {
   } else {
     enablePrioritySelectMode();
   }
+  resetPtme();
+  ptmeLocked = false;
 
 #if OBSW_SYRLINKS_SIMULATED == 1
   // Update data on rising edge
@@ -127,10 +133,15 @@ ReturnValue_t CcsdsIpCoreHandler::getParameter(uint8_t domainId, uint8_t uniqueI
       return HasParametersIF::INVALID_VALUE;
     }
     parameterWrapper->set(batPriorityParam);
-    if (mode == MODE_ON) {
-      updateBatPriorityOnTxOff = true;
-    } else if (mode == MODE_OFF) {
-      updateBatPriorityFromParam();
+    if (newVal != batPriorityParam) {
+      // This ensures that the BAT priority is updated at some point when an update of the PTME is
+      // allowed
+      updateContext.updateBatPrio = true;
+      // If we are off, we can do the update after X cycles. Otherwise, wait until the transmitter
+      // goes off.
+      if (mode == MODE_OFF) {
+        initPtmeUpdateAfterXCycles();
+      }
     }
     return returnvalue::OK;
   }
@@ -148,36 +159,12 @@ ReturnValue_t CcsdsIpCoreHandler::executeAction(ActionId_t actionId, MessageQueu
                                                 const uint8_t* data, size_t size) {
   ReturnValue_t result = returnvalue::OK;
   switch (actionId) {
-    case SET_LOW_RATE: {
-      submode = static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_LOW);
-      result = ptmeConfig.setRate(RATE_100KBPS);
-      break;
-    }
-    case SET_HIGH_RATE: {
-      submode = static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_HIGH);
-      result = ptmeConfig.setRate(RATE_500KBPS);
-      break;
-    }
     case ARBITRARY_RATE: {
       uint32_t bitrate = 0;
       SerializeAdapter::deSerialize(&bitrate, &data, &size, SerializeIF::Endianness::BIG);
       result = ptmeConfig.setRate(bitrate);
       break;
     }
-    case EN_TRANSMITTER: {
-      enableTransmit();
-      if (mode == HasModesIF::MODE_OFF) {
-        mode = HasModesIF::MODE_ON;
-      }
-      return EXECUTION_FINISHED;
-    }
-    case DISABLE_TRANSMITTER: {
-      disableTransmit();
-      if (mode == HasModesIF::MODE_ON) {
-        mode = HasModesIF::MODE_OFF;
-      }
-      return EXECUTION_FINISHED;
-    }
     case ENABLE_TX_CLK_MANIPULATOR: {
       result = ptmeConfig.configTxManipulator(true);
       break;
@@ -206,12 +193,8 @@ ReturnValue_t CcsdsIpCoreHandler::executeAction(ActionId_t actionId, MessageQueu
 void CcsdsIpCoreHandler::updateLinkState() { linkState = LINK_UP; }
 
 void CcsdsIpCoreHandler::enableTransmit() {
-  // Reset PTME on each transmit enable.
-  updateBatPriorityFromParam();
-#ifndef TE0720_1CFA
   gpioIF->pullHigh(ptmeGpios.enableTxClock);
   gpioIF->pullHigh(ptmeGpios.enableTxData);
-#endif
   linkState = LINK_UP;
 }
 
@@ -236,34 +219,23 @@ ReturnValue_t CcsdsIpCoreHandler::checkModeCommand(Mode_t mode, Submode_t submod
 }
 
 void CcsdsIpCoreHandler::startTransition(Mode_t mode, Submode_t submode) {
-  auto rateSet = [&](uint32_t rate) {
-    ReturnValue_t result = ptmeConfig.setRate(rate);
-    if (result == returnvalue::OK) {
-      this->mode = HasModesIF::MODE_ON;
-    }
-  };
+  triggerEvent(CHANGING_MODE, mode, submode);
   if (mode == HasModesIF::MODE_ON) {
-    enableTransmit();
-    if (submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_DEFAULT)) {
-      com::Datarate currentDatarate = com::getCurrentDatarate();
-      if (currentDatarate == com::Datarate::LOW_RATE_MODULATION_BPSK) {
-        rateSet(RATE_100KBPS);
-      } else if (currentDatarate == com::Datarate::HIGH_RATE_MODULATION_0QPSK) {
-        rateSet(RATE_500KBPS);
-      }
-    } else if (submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_HIGH)) {
-      rateSet(RATE_500KBPS);
-    } else if (submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_LOW)) {
-      rateSet(RATE_100KBPS);
+    if (this->submode != submode) {
+      initPtmeUpdateAfterXCycles();
+      updateContext.enableTransmitAfterPtmeUpdate = true;
+      updateContext.updateClockRate = true;
+      this->submode = submode;
+      this->mode = mode;
+      updateContext.setModeAfterUpdate = true;
+      return;
     }
-
+    // No rate change, so enable transmitter right away.
+    enableTransmit();
   } else if (mode == HasModesIF::MODE_OFF) {
     disableTransmit();
-    this->mode = HasModesIF::MODE_OFF;
   }
-  this->submode = submode;
-  modeHelper.modeChanged(mode, submode);
-  announceMode(false);
+  setMode(mode, submode);
 }
 
 void CcsdsIpCoreHandler::announceMode(bool recursive) { triggerEvent(MODE_INFO, mode, submode); }
@@ -274,9 +246,9 @@ void CcsdsIpCoreHandler::disableTransmit() {
   gpioIF->pullLow(ptmeGpios.enableTxData);
 #endif
   linkState = LINK_DOWN;
-  if (updateBatPriorityOnTxOff) {
-    updateBatPriorityFromParam();
-    updateBatPriorityOnTxOff = false;
+  // Some parameters need update and transmitter is off now.
+  if (updateContext.updateBatPrio or updateContext.updateClockRate) {
+    initPtmeUpdateAfterXCycles();
   }
 }
 
@@ -294,21 +266,9 @@ ModeTreeChildIF& CcsdsIpCoreHandler::getModeTreeChildIF() { return *this; }
 
 object_id_t CcsdsIpCoreHandler::getObjectId() const { return SystemObject::getObjectId(); }
 
-void CcsdsIpCoreHandler::enablePrioritySelectMode() {
-  ptmeConfig.enableBatPriorityBit(true);
-  // Reset the PTME
-  gpioIF->pullLow(ptmeGpios.ptmeResetn);
-  usleep(10);
-  gpioIF->pullHigh(ptmeGpios.ptmeResetn);
-}
+void CcsdsIpCoreHandler::enablePrioritySelectMode() { ptmeConfig.enableBatPriorityBit(true); }
 
-void CcsdsIpCoreHandler::disablePrioritySelectMode() {
-  ptmeConfig.enableBatPriorityBit(false);
-  // Reset the PTME
-  gpioIF->pullLow(ptmeGpios.ptmeResetn);
-  usleep(10);
-  gpioIF->pullHigh(ptmeGpios.ptmeResetn);
-}
+void CcsdsIpCoreHandler::disablePrioritySelectMode() { ptmeConfig.enableBatPriorityBit(false); }
 
 void CcsdsIpCoreHandler::updateBatPriorityFromParam() {
   if (batPriorityParam == 0) {
@@ -317,3 +277,79 @@ void CcsdsIpCoreHandler::updateBatPriorityFromParam() {
     enablePrioritySelectMode();
   }
 }
+
+void CcsdsIpCoreHandler::setMode(Mode_t mode, Submode_t submode) {
+  this->submode = submode;
+  this->mode = mode;
+  modeHelper.modeChanged(mode, submode);
+  announceMode(false);
+}
+
+void CcsdsIpCoreHandler::performPtmeUpdateWhenApplicable() {
+  if (not updateContext.performPtmeUpdateAfterXCycles) {
+    return;
+  }
+  if (updateContext.ptmeUpdateCycleCount >= 2) {
+    if (updateContext.updateBatPrio) {
+      updateBatPriorityFromParam();
+      updateContext.updateBatPrio = false;
+    }
+    ReturnValue_t result = returnvalue::OK;
+    if (updateContext.updateClockRate) {
+      if (submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_DEFAULT)) {
+        com::Datarate currentDatarate = com::getCurrentDatarate();
+        if (currentDatarate == com::Datarate::LOW_RATE_MODULATION_BPSK) {
+          result = ptmeConfig.setRate(RATE_100KBPS);
+        } else if (currentDatarate == com::Datarate::HIGH_RATE_MODULATION_0QPSK) {
+          result = ptmeConfig.setRate(RATE_500KBPS);
+        }
+      } else if (submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_HIGH)) {
+        result = ptmeConfig.setRate(RATE_500KBPS);
+      } else if (submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_LOW)) {
+        result = ptmeConfig.setRate(RATE_100KBPS);
+      }
+      if (result != returnvalue::OK) {
+        sif::error << "CcsdsIpCoreHandler: Setting datarate failed" << std::endl;
+      }
+      updateContext.updateClockRate = false;
+    }
+    bool doResetPtme = true;
+    if (not updateContext.updateBatPrio and not updateContext.updateClockRate) {
+      doResetPtme = false;
+    }
+    finishPtmeUpdateAfterXCycles(doResetPtme);
+    return;
+  }
+  updateContext.ptmeUpdateCycleCount++;
+}
+
+void CcsdsIpCoreHandler::resetPtme() {
+  gpioIF->pullLow(ptmeGpios.ptmeResetn);
+  usleep(10);
+  gpioIF->pullHigh(ptmeGpios.ptmeResetn);
+}
+
+void CcsdsIpCoreHandler::initPtmeUpdateAfterXCycles() {
+  if (not updateContext.performPtmeUpdateAfterXCycles) {
+    updateContext.performPtmeUpdateAfterXCycles = true;
+    updateContext.ptmeUpdateCycleCount = 0;
+    ptmeLocked = true;
+  }
+}
+
+void CcsdsIpCoreHandler::finishPtmeUpdateAfterXCycles(bool doResetPtme) {
+  if (doResetPtme) {
+    resetPtme();
+  }
+  ptmeLocked = false;
+  updateContext.performPtmeUpdateAfterXCycles = false;
+  updateContext.ptmeUpdateCycleCount = 0;
+  if (updateContext.enableTransmitAfterPtmeUpdate) {
+    enableTransmit();
+    updateContext.enableTransmitAfterPtmeUpdate = false;
+  }
+  if (updateContext.setModeAfterUpdate) {
+    setMode(mode, submode);
+    updateContext.setModeAfterUpdate = false;
+  }
+}

mission/com/CcsdsIpCoreHandler.h

@@ -2,7 +2,7 @@
 #define CCSDSHANDLER_H_
 
 #include <fsfw/modes/HasModesIF.h>
-#include <mission/tmtc/VirtualChannelWithQueue.h>
+#include <mission/com/VirtualChannelWithQueue.h>
 
 #include <cstdint>
 #include <unordered_map>
@@ -79,7 +79,8 @@ class CcsdsIpCoreHandler : public SystemObject,
    * @param enTxData  GPIO ID of RS485 tx data enable
    */
   CcsdsIpCoreHandler(object_id_t objectId, object_id_t tcDestination, PtmeConfig& ptmeConfig,
-                     std::atomic_bool& linkState, GpioIF* gpioIF, PtmeGpios gpioIds);
+                     std::atomic_bool& linkState, GpioIF* gpioIF, PtmeGpios gpioIds,
+                     std::atomic_bool& ptmeLocked);
 
   ~CcsdsIpCoreHandler();
 
@@ -137,9 +138,8 @@ class CcsdsIpCoreHandler : public SystemObject,
   //! [EXPORT] : [COMMENT] Received action message with unknown action id
   static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xA0);
 
-  // using VirtualChannelMap = std::unordered_map<VcId_t, VirtualChannelWithQueue*>;
-  // VirtualChannelMap virtualChannelMap;
   std::atomic_bool& linkState;
+  std::atomic_bool& ptmeLocked;
 
   object_id_t tcDestination;
 
@@ -158,7 +158,15 @@ class CcsdsIpCoreHandler : public SystemObject,
   PtmeGpios ptmeGpios;
   // BAT priority bit on by default to enable priority selection mode for the PTME.
   uint8_t batPriorityParam = 0;
-  bool updateBatPriorityOnTxOff = false;
+
+  struct UpdateContext {
+    bool updateBatPrio = false;
+    bool updateClockRate = false;
+    bool enableTransmitAfterPtmeUpdate = false;
+    uint8_t ptmeUpdateCycleCount = 0;
+    bool performPtmeUpdateAfterXCycles = false;
+    bool setModeAfterUpdate = false;
+  } updateContext{};
 
   GpioIF* gpioIF = nullptr;
 
@@ -180,6 +188,8 @@ class CcsdsIpCoreHandler : public SystemObject,
    */
   void disableTransmit();
 
+  void performPtmeUpdateWhenApplicable();
+
   /**
    * The following set of functions configure the mode of the PTME bandwith allocation table (BAT)
    * module. This consists of the following 2 steps:
@@ -189,6 +199,11 @@ class CcsdsIpCoreHandler : public SystemObject,
   void enablePrioritySelectMode();
   void disablePrioritySelectMode();
   void updateBatPriorityFromParam();
+
+  void setMode(Mode_t mode, Submode_t submode);
+  void resetPtme();
+  void initPtmeUpdateAfterXCycles();
+  void finishPtmeUpdateAfterXCycles(bool doResetPtme);
 };
 
 #endif /* CCSDSHANDLER_H_ */

mission/com/LiveTmTask.cpp

@@ -0,0 +1,107 @@
+#include "LiveTmTask.h"
+
+#include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/subsystem/helper.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
+
+LiveTmTask::LiveTmTask(object_id_t objectId, PusTmFunnel& pusFunnel, CfdpTmFunnel& cfdpFunnel,
+                       VirtualChannelWithQueue& channel, const std::atomic_bool& ptmeLocked)
+    : SystemObject(objectId),
+      modeHelper(this),
+      pusFunnel(pusFunnel),
+      cfdpFunnel(cfdpFunnel),
+      channel(channel),
+      ptmeLocked(ptmeLocked) {
+  requestQueue = QueueFactory::instance()->createMessageQueue();
+}
+
+ReturnValue_t LiveTmTask::performOperation(uint8_t opCode) {
+  readCommandQueue();
+  while (true) {
+    bool performWriteOp = true;
+    if (mode == MODE_OFF or ptmeLocked) {
+      performWriteOp = false;
+    }
+
+    // The funnel tasks are scheduled here directly as well.
+    ReturnValue_t result = channel.handleNextTm(performWriteOp);
+    if (result == DirectTmSinkIF::IS_BUSY) {
+      sif::error << "Lost live TM, PAPB busy" << std::endl;
+    }
+    if (result == MessageQueueIF::EMPTY) {
+      if (tmFunnelCd.hasTimedOut()) {
+        pusFunnel.performOperation(0);
+        cfdpFunnel.performOperation(0);
+        tmFunnelCd.resetTimer();
+      }
+      // Read command queue during idle times.
+      readCommandQueue();
+      // 40 ms IDLE delay. Might tweak this in the future.
+      TaskFactory::delayTask(40);
+    } else {
+      packetCounter++;
+    }
+  }
+}
+
+MessageQueueId_t LiveTmTask::getCommandQueue() const { return requestQueue->getId(); }
+
+void LiveTmTask::getMode(Mode_t* mode, Submode_t* submode) {
+  if (mode != nullptr) {
+    *mode = this->mode;
+  }
+  if (submode != nullptr) {
+    *submode = SUBMODE_NONE;
+  }
+}
+
+ReturnValue_t LiveTmTask::checkModeCommand(Mode_t mode, Submode_t submode,
+                                           uint32_t* msToReachTheMode) {
+  if (mode == MODE_ON or mode == MODE_OFF) {
+    return returnvalue::OK;
+  }
+  return returnvalue::FAILED;
+}
+
+void LiveTmTask::startTransition(Mode_t mode, Submode_t submode) {
+  this->mode = mode;
+  modeHelper.modeChanged(mode, submode);
+  announceMode(false);
+}
+
+void LiveTmTask::announceMode(bool recursive) { triggerEvent(MODE_INFO, mode, SUBMODE_NONE); }
+
+object_id_t LiveTmTask::getObjectId() const { return SystemObject::getObjectId(); }
+
+const HasHealthIF* LiveTmTask::getOptHealthIF() const { return nullptr; }
+
+const HasModesIF& LiveTmTask::getModeIF() const { return *this; }
+
+ReturnValue_t LiveTmTask::connectModeTreeParent(HasModeTreeChildrenIF& parent) {
+  return modetree::connectModeTreeParent(parent, *this, nullptr, modeHelper);
+}
+
+void LiveTmTask::readCommandQueue(void) {
+  CommandMessage commandMessage;
+  ReturnValue_t result = returnvalue::FAILED;
+
+  result = requestQueue->receiveMessage(&commandMessage);
+  if (result == returnvalue::OK) {
+    result = modeHelper.handleModeCommand(&commandMessage);
+    if (result == returnvalue::OK) {
+      return;
+    }
+    CommandMessage reply;
+    reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND, commandMessage.getCommand());
+    requestQueue->reply(&reply);
+    return;
+  }
+}
+
+ModeTreeChildIF& LiveTmTask::getModeTreeChildIF() { return *this; }
+
+ReturnValue_t LiveTmTask::initialize() {
+  modeHelper.initialize();
+  return returnvalue::OK;
+}

mission/com/LiveTmTask.h

@@ -0,0 +1,57 @@
+#ifndef MISSION_TMTC_LIVETMTASK_H_
+#define MISSION_TMTC_LIVETMTASK_H_
+
+#include <fsfw/modes/HasModesIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/subsystem/ModeTreeChildIF.h>
+#include <fsfw/subsystem/ModeTreeConnectionIF.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+#include <fsfw/timemanager/Countdown.h>
+#include <mission/com/VirtualChannelWithQueue.h>
+#include <mission/tmtc/CfdpTmFunnel.h>
+#include <mission/tmtc/PusTmFunnel.h>
+
+class LiveTmTask : public SystemObject,
+                   public HasModesIF,
+                   public ExecutableObjectIF,
+                   public ModeTreeChildIF,
+                   public ModeTreeConnectionIF {
+ public:
+  LiveTmTask(object_id_t objectId, PusTmFunnel& pusFunnel, CfdpTmFunnel& cfdpFunnel,
+             VirtualChannelWithQueue& channel, const std::atomic_bool& ptmeLocked);
+
+  ReturnValue_t performOperation(uint8_t opCode) override;
+  ReturnValue_t initialize() override;
+  ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent) override;
+
+ private:
+  MessageQueueIF* requestQueue;
+  ModeHelper modeHelper;
+  Mode_t mode = HasModesIF::MODE_OFF;
+  Countdown tmFunnelCd = Countdown(100);
+  PusTmFunnel& pusFunnel;
+  CfdpTmFunnel& cfdpFunnel;
+  VirtualChannelWithQueue& channel;
+  uint32_t packetCounter = 0;
+  const std::atomic_bool& ptmeLocked;
+
+  void readCommandQueue(void);
+
+  MessageQueueId_t getCommandQueue() const override;
+
+  void getMode(Mode_t* mode, Submode_t* submode) override;
+
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t* msToReachTheMode) override;
+
+  void startTransition(Mode_t mode, Submode_t submode) override;
+
+  void announceMode(bool recursive) override;
+
+  object_id_t getObjectId() const override;
+  const HasHealthIF* getOptHealthIF() const override;
+  const HasModesIF& getModeIF() const override;
+  ModeTreeChildIF& getModeTreeChildIF() override;
+};
+
+#endif /* MISSION_TMTC_LIVETMTASK_H_ */

mission/com/PersistentLogTmStoreTask.cpp

@@ -5,8 +5,9 @@
 
 PersistentLogTmStoreTask::PersistentLogTmStoreTask(object_id_t objectId, StorageManagerIF& ipcStore,
                                                    LogStores stores, VirtualChannel& channel,
-                                                   SdCardMountedIF& sdcMan)
-    : TmStoreTaskBase(objectId, ipcStore, channel, sdcMan),
+                                                   SdCardMountedIF& sdcMan,
+                                                   const std::atomic_bool& ptmeLocked)
+    : TmStoreTaskBase(objectId, ipcStore, channel, sdcMan, ptmeLocked),
       stores(stores),
       okStoreContext(persTmStore::DUMP_OK_STORE_DONE, persTmStore::DUMP_OK_CANCELLED),
       notOkStoreContext(persTmStore::DUMP_NOK_STORE_DONE, persTmStore::DUMP_NOK_CANCELLED),
@@ -27,6 +28,8 @@ ReturnValue_t PersistentLogTmStoreTask::performOperation(uint8_t opCode) {
     }
   };
   while (true) {
+    readCommandQueue();
+
     if (not cyclicStoreCheck()) {
       continue;
     }
@@ -40,6 +43,7 @@ ReturnValue_t PersistentLogTmStoreTask::performOperation(uint8_t opCode) {
       TaskFactory::delayTask(100);
     } else if (vcBusyDuringDump) {
       // TODO: Might not be necessary
+      sif::debug << "VC busy, delaying" << std::endl;
       TaskFactory::delayTask(10);
     }
   }
@@ -54,3 +58,17 @@ bool PersistentLogTmStoreTask::initStoresIfPossible() {
   }
   return false;
 }
+
+void PersistentLogTmStoreTask::startTransition(Mode_t mode, Submode_t submode) {
+  if (mode == MODE_OFF) {
+    bool channelIsOn = channel.isTxOn();
+    cancelDump(okStoreContext, stores.okStore, channelIsOn);
+    cancelDump(notOkStoreContext, stores.notOkStore, channelIsOn);
+    cancelDump(miscStoreContext, stores.miscStore, channelIsOn);
+    this->mode = MODE_OFF;
+  } else if (mode == MODE_ON) {
+    this->mode = MODE_ON;
+  }
+  modeHelper.modeChanged(mode, submode);
+  announceMode(false);
+}

mission/com/PersistentLogTmStoreTask.h

@@ -5,11 +5,11 @@
 #include <fsfw/storagemanager/StorageManagerIF.h>
 #include <fsfw/tasks/ExecutableObjectIF.h>
 #include <fsfw/tmtcservices/AcceptsTelemetryIF.h>
+#include <mission/com/TmStoreTaskBase.h>
+#include <mission/com/VirtualChannelWithQueue.h>
 #include <mission/genericFactory.h>
 #include <mission/tmtc/PersistentTmStore.h>
 #include <mission/tmtc/PersistentTmStoreWithTmQueue.h>
-#include <mission/tmtc/TmStoreTaskBase.h>
-#include <mission/tmtc/VirtualChannelWithQueue.h>
 
 struct LogStores {
   LogStores(PersistentTmStores& stores)
@@ -22,7 +22,8 @@ struct LogStores {
 class PersistentLogTmStoreTask : public TmStoreTaskBase, public ExecutableObjectIF {
  public:
   PersistentLogTmStoreTask(object_id_t objectId, StorageManagerIF& ipcStore, LogStores tmStore,
-                           VirtualChannel& channel, SdCardMountedIF& sdcMan);
+                           VirtualChannel& channel, SdCardMountedIF& sdcMan,
+                           const std::atomic_bool& ptmeLocked);
 
   ReturnValue_t performOperation(uint8_t opCode) override;
 
@@ -36,6 +37,7 @@ class PersistentLogTmStoreTask : public TmStoreTaskBase, public ExecutableObject
   bool someFileWasSwapped = false;
 
   bool initStoresIfPossible() override;
+  void startTransition(Mode_t mode, Submode_t submode) override;
 };
 
 #endif /* MISSION_TMTC_PERSISTENTLOGTMSTORETASK_H_ */

mission/com/PersistentSingleTmStoreTask.cpp

@@ -1,17 +1,21 @@
+#include "PersistentSingleTmStoreTask.h"
+
 #include <fsfw/tasks/TaskFactory.h>
 #include <fsfw/timemanager/Stopwatch.h>
-#include <mission/tmtc/PersistentSingleTmStoreTask.h>
 #include <unistd.h>
 
 PersistentSingleTmStoreTask::PersistentSingleTmStoreTask(
     object_id_t objectId, StorageManagerIF& ipcStore, PersistentTmStoreWithTmQueue& tmStore,
-    VirtualChannel& channel, Event eventIfDumpDone, Event eventIfCancelled, SdCardMountedIF& sdcMan)
-    : TmStoreTaskBase(objectId, ipcStore, channel, sdcMan),
+    VirtualChannel& channel, Event eventIfDumpDone, Event eventIfCancelled, SdCardMountedIF& sdcMan,
+    const std::atomic_bool& ptmeLocked)
+    : TmStoreTaskBase(objectId, ipcStore, channel, sdcMan, ptmeLocked),
       storeWithQueue(tmStore),
       dumpContext(eventIfDumpDone, eventIfCancelled) {}
 
 ReturnValue_t PersistentSingleTmStoreTask::performOperation(uint8_t opCode) {
   while (true) {
+    readCommandQueue();
+
     // Delay done by the check
     if (not cyclicStoreCheck()) {
       continue;
@@ -20,8 +24,12 @@ ReturnValue_t PersistentSingleTmStoreTask::performOperation(uint8_t opCode) {
     if (not busy) {
       TaskFactory::delayTask(100);
     } else if (dumpContext.vcBusyDuringDump) {
+      sif::debug << "VC busy, delaying" << std::endl;
       // TODO: Might not be necessary
       TaskFactory::delayTask(10);
+    } else {
+      // TODO: Would be best to remove this, but not delaying here can lead to evil issues.
+      TaskFactory::delayTask(10);
     }
   }
 }
@@ -33,3 +41,14 @@ bool PersistentSingleTmStoreTask::initStoresIfPossible() {
   }
   return false;
 }
+
+void PersistentSingleTmStoreTask::startTransition(Mode_t mode, Submode_t submode) {
+  if (mode == MODE_OFF) {
+    cancelDump(dumpContext, storeWithQueue, channel.isTxOn());
+    this->mode = MODE_OFF;
+  } else if (mode == MODE_ON) {
+    this->mode = MODE_ON;
+  }
+  modeHelper.modeChanged(mode, submode);
+  announceMode(false);
+}

mission/com/PersistentSingleTmStoreTask.h

@@ -3,16 +3,16 @@
 
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/tasks/ExecutableObjectIF.h>
+#include <mission/com/TmStoreTaskBase.h>
+#include <mission/com/VirtualChannel.h>
 #include <mission/tmtc/PersistentTmStoreWithTmQueue.h>
-#include <mission/tmtc/TmStoreTaskBase.h>
-#include <mission/tmtc/VirtualChannel.h>
 
 class PersistentSingleTmStoreTask : public TmStoreTaskBase, public ExecutableObjectIF {
  public:
   PersistentSingleTmStoreTask(object_id_t objectId, StorageManagerIF& ipcStore,
                               PersistentTmStoreWithTmQueue& storeWithQueue, VirtualChannel& channel,
                               Event eventIfDumpDone, Event eventIfCancelled,
-                              SdCardMountedIF& sdcMan);
+                              SdCardMountedIF& sdcMan, const std::atomic_bool& ptmeLocked);
 
   ReturnValue_t performOperation(uint8_t opCode) override;
 
@@ -23,6 +23,8 @@ class PersistentSingleTmStoreTask : public TmStoreTaskBase, public ExecutableObj
   Countdown graceDelayDuringDumping = Countdown(100);
 
   bool initStoresIfPossible() override;
+
+  void startTransition(Mode_t mode, Submode_t submode) override;
 };
 
 #endif /* MISSION_TMTC_PERSISTENTSINGLETMSTORETASK_H_ */

mission/com/SyrlinksHandler.cpp

@@ -21,6 +21,7 @@ SyrlinksHandler::~SyrlinksHandler() = default;
 
 void SyrlinksHandler::doStartUp() {
   if (internalState == InternalState::OFF) {
+    transitionCommandPending = false;
     internalState = InternalState::ENABLE_TEMPERATURE_PROTECTION;
     commandExecuted = false;
   }
@@ -38,6 +39,7 @@ void SyrlinksHandler::doShutDown() {
   // In any case, always disable TX first.
   if (internalState != InternalState::SET_TX_STANDBY) {
     internalState = InternalState::SET_TX_STANDBY;
+    transitionCommandPending = false;
     commandExecuted = false;
   }
   if (internalState == InternalState::SET_TX_STANDBY) {
@@ -122,8 +124,9 @@ ReturnValue_t SyrlinksHandler::buildTransitionDeviceCommand(DeviceCommandId_t* i
       *id = syrlinks::SET_TX_MODE_STANDBY;
       return buildCommandFromCommand(*id, nullptr, 0);
     }
-    default:
+    default: {
       break;
+    }
   }
   return NOTHING_TO_SEND;
 }
@@ -442,7 +445,6 @@ ReturnValue_t SyrlinksHandler::interpretDeviceReply(DeviceCommandId_t id, const
       return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
     }
   }
-
   return returnvalue::OK;
 }
 
@@ -682,6 +684,9 @@ ReturnValue_t SyrlinksHandler::handleAckReply(const uint8_t* packet) {
       }
       break;
     }
+    default: {
+      sif::error << "Syrlinks: Unexpected ACK reply" << std::endl;
+    }
   }
   switch (rememberCommandId) {
     case (syrlinks::SET_TX_MODE_STANDBY): {
@@ -728,16 +733,19 @@ void SyrlinksHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
   Mode_t tgtMode = getBaseMode(getMode());
   auto commandDone = [&]() {
     setMode(tgtMode);
+    transitionCommandPending = false;
     internalState = InternalState::IDLE;
   };
   auto txOnHandler = [&](InternalState selMod) {
     if (internalState == InternalState::IDLE) {
+      transitionCommandPending = false;
       commandExecuted = false;
       internalState = selMod;
     }
     // Select modulation first (BPSK or 0QPSK).
     if (internalState == selMod) {
       if (commandExecuted) {
+        transitionCommandPending = false;
         internalState = InternalState::SET_TX_MODULATION;
         commandExecuted = false;
       }
@@ -753,6 +761,7 @@ void SyrlinksHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
   };
   auto txStandbyHandler = [&]() {
     if (internalState == InternalState::IDLE) {
+      transitionCommandPending = false;
       internalState = InternalState::SET_TX_STANDBY;
       commandExecuted = false;
     }

mission/com/SyrlinksHandler.h

@@ -112,6 +112,7 @@ class SyrlinksHandler : public DeviceHandlerBase {
   float tempPowerAmplifier = 0;
   float tempBasebandBoard = 0;
   bool commandExecuted = false;
+  bool transitionCommandPending = false;
 
   uint8_t commandBuffer[syrlinks::MAX_COMMAND_SIZE];
 

mission/com/TmStoreTaskBase.cpp

@@ -0,0 +1,228 @@
+#include "TmStoreTaskBase.h"
+
+#include <fsfw/ipc/CommandMessageIF.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/subsystem/helper.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
+#include <fsfw/tmstorage/TmStoreMessage.h>
+
+#include "mission/persistentTmStoreDefs.h"
+
+TmStoreTaskBase::TmStoreTaskBase(object_id_t objectId, StorageManagerIF& ipcStore,
+                                 VirtualChannel& channel, SdCardMountedIF& sdcMan,
+                                 const std::atomic_bool& ptmeLocked)
+    : SystemObject(objectId),
+      modeHelper(this),
+      ipcStore(ipcStore),
+      tmReader(&timeReader),
+      channel(channel),
+      sdcMan(sdcMan),
+      ptmeLocked(ptmeLocked) {
+  requestQueue = QueueFactory::instance()->createMessageQueue(10);
+}
+
+bool TmStoreTaskBase::handleOneStore(PersistentTmStoreWithTmQueue& store,
+                                     DumpContext& dumpContext) {
+  ReturnValue_t result;
+  bool tmToStoreReceived = false;
+  bool tcRequestReceived = false;
+  bool dumpPerformed = false;
+  fileHasSwapped = false;
+  dumpContext.packetWasDumped = false;
+  dumpContext.vcBusyDuringDump = false;
+
+  // Store TM persistently
+  result = store.handleNextTm();
+  if (result == returnvalue::OK) {
+    tmToStoreReceived = true;
+  }
+  // Dump TMs
+  if (store.getState() == PersistentTmStore::State::DUMPING) {
+    if (handleOneDump(store, dumpContext, dumpPerformed) != returnvalue::OK) {
+      return result;
+    }
+  } else {
+    Command_t execCmd;
+    // Handle TC requests, for example deletion or retrieval requests.
+    result = store.handleCommandQueue(ipcStore, execCmd);
+    if (result == returnvalue::OK) {
+      if (execCmd == TmStoreMessage::DOWNLINK_STORE_CONTENT_TIME) {
+        cancelDumpCd.resetTimer();
+        tmSinkBusyCd.resetTimer();
+        dumpContext.reset();
+      }
+      tcRequestReceived = true;
+    }
+  }
+  if (tcRequestReceived or tmToStoreReceived or dumpPerformed) {
+    return true;
+  }
+  return false;
+}
+
+bool TmStoreTaskBase::cyclicStoreCheck() {
+  if (not storesInitialized) {
+    storesInitialized = initStoresIfPossible();
+    if (not storesInitialized) {
+      TaskFactory::delayTask(400);
+      return false;
+    }
+  } else if (sdCardCheckCd.hasTimedOut()) {
+    if (not sdcMan.isSdCardUsable(std::nullopt)) {
+      // Might be due to imminent shutdown or SD card switch.
+      storesInitialized = false;
+      TaskFactory::delayTask(100);
+      return false;
+    }
+    sdCardCheckCd.resetTimer();
+  }
+  return true;
+}
+
+void TmStoreTaskBase::cancelDump(DumpContext& ctx, PersistentTmStore& store, bool isTxOn) {
+  ctx.reset();
+  if (store.getState() == PersistentTmStore::State::DUMPING) {
+    triggerEvent(ctx.eventIfCancelled, ctx.numberOfDumpedPackets, ctx.dumpedBytes);
+  }
+  store.cancelDump();
+  if (isTxOn) {
+    channel.cancelTransfer();
+  }
+}
+
+ReturnValue_t TmStoreTaskBase::handleOneDump(PersistentTmStoreWithTmQueue& store,
+                                             DumpContext& dumpContext, bool& dumpPerformed) {
+  ReturnValue_t result = returnvalue::OK;
+  // The PTME might have been reset an transmitter state change, so there is no point in continuing
+  // the dump.
+  // TODO: Will be solved in a cleaner way, this is kind of a hack.
+  if (not channel.isTxOn()) {
+    cancelDump(dumpContext, store, false);
+    return returnvalue::FAILED;
+  }
+  // It is assumed that the PTME will only be locked for a short period (e.g. to change datarate).
+  if (not channel.isBusy() and not ptmeLocked) {
+    performDump(store, dumpContext, dumpPerformed);
+  } else {
+    // The PTME might be at full load, so it might sense to delay for a bit to let it do
+    // its work until some more bandwidth is available. Set a flag here so the upper layer can
+    // do ths.
+    dumpContext.vcBusyDuringDump = true;
+    dumpContext.ptmeBusyCounter++;
+    if (dumpContext.ptmeBusyCounter == 100) {
+      // If this happens, something is probably wrong.
+      sif::warning << "PTME busy for longer period. Cancelling dump" << std::endl;
+      cancelDump(dumpContext, store, channel.isTxOn());
+    }
+  }
+  if (cancelDumpCd.hasTimedOut() or tmSinkBusyCd.hasTimedOut()) {
+    cancelDump(dumpContext, store, channel.isTxOn());
+  }
+  return result;
+}
+
+ReturnValue_t TmStoreTaskBase::performDump(PersistentTmStoreWithTmQueue& store,
+                                           DumpContext& dumpContext, bool& dumpPerformed) {
+  size_t dumpedLen = 0;
+
+  auto dumpDoneHandler = [&]() {
+    uint32_t startTime;
+    uint32_t endTime;
+    store.getStartAndEndTimeCurrentOrLastDump(startTime, endTime);
+    triggerEvent(dumpContext.eventIfDone, dumpContext.numberOfDumpedPackets,
+                 dumpContext.dumpedBytes);
+    dumpContext.reset();
+  };
+  // Dump the next packet into the PTME.
+  dumpContext.ptmeBusyCounter = 0;
+  tmSinkBusyCd.resetTimer();
+  ReturnValue_t result = store.getNextDumpPacket(tmReader, fileHasSwapped);
+  if (result != returnvalue::OK) {
+    sif::error << "PersistentTmStore: Getting next dump packet failed" << std::endl;
+  } else if (fileHasSwapped or result == PersistentTmStore::DUMP_DONE) {
+    // This can happen if a file is corrupted and the next file swap completes the dump.
+    dumpDoneHandler();
+    return returnvalue::OK;
+  }
+  dumpedLen = tmReader.getFullPacketLen();
+  // Only write to VC if mode is on, but always confirm the dump.
+  // If the mode is OFF, it is assumed the PTME is not usable and is not allowed to be written
+  // (e.g. to confirm a reset or the transmitter is off anyway).
+  if (mode == MODE_ON) {
+    result = channel.write(tmReader.getFullData(), dumpedLen);
+    if (result == DirectTmSinkIF::IS_BUSY) {
+      sif::warning << "PersistentTmStore: Unexpected VC channel busy" << std::endl;
+    } else if (result != returnvalue::OK) {
+      sif::warning << "PersistentTmStore: Unexpected VC channel write failure" << std::endl;
+    }
+  }
+  result = store.confirmDump(tmReader, fileHasSwapped);
+  if ((result == PersistentTmStore::DUMP_DONE or result == returnvalue::OK)) {
+    dumpPerformed = true;
+    if (dumpedLen > 0) {
+      dumpContext.dumpedBytes += dumpedLen;
+      dumpContext.numberOfDumpedPackets += 1;
+      dumpContext.packetWasDumped = true;
+    }
+  }
+  if (result == PersistentTmStore::DUMP_DONE) {
+    dumpDoneHandler();
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t TmStoreTaskBase::initialize() {
+  modeHelper.initialize();
+  return returnvalue::OK;
+}
+
+void TmStoreTaskBase::getMode(Mode_t* mode, Submode_t* submode) {
+  if (mode != nullptr) {
+    *mode = this->mode;
+  }
+  if (submode != nullptr) {
+    *submode = SUBMODE_NONE;
+  }
+}
+
+ReturnValue_t TmStoreTaskBase::checkModeCommand(Mode_t mode, Submode_t submode,
+                                                uint32_t* msToReachTheMode) {
+  if (mode == MODE_ON or mode == MODE_OFF) {
+    return returnvalue::OK;
+  }
+  return returnvalue::FAILED;
+}
+
+MessageQueueId_t TmStoreTaskBase::getCommandQueue() const { return requestQueue->getId(); }
+
+void TmStoreTaskBase::announceMode(bool recursive) { triggerEvent(MODE_INFO, mode, SUBMODE_NONE); }
+
+object_id_t TmStoreTaskBase::getObjectId() const { return SystemObject::getObjectId(); }
+
+const HasHealthIF* TmStoreTaskBase::getOptHealthIF() const { return nullptr; }
+
+const HasModesIF& TmStoreTaskBase::getModeIF() const { return *this; }
+
+ReturnValue_t TmStoreTaskBase::connectModeTreeParent(HasModeTreeChildrenIF& parent) {
+  return modetree::connectModeTreeParent(parent, *this, nullptr, modeHelper);
+}
+
+ModeTreeChildIF& TmStoreTaskBase::getModeTreeChildIF() { return *this; }
+
+void TmStoreTaskBase::readCommandQueue(void) {
+  CommandMessage commandMessage;
+  ReturnValue_t result = returnvalue::FAILED;
+
+  result = requestQueue->receiveMessage(&commandMessage);
+  if (result == returnvalue::OK) {
+    result = modeHelper.handleModeCommand(&commandMessage);
+    if (result == returnvalue::OK) {
+      return;
+    }
+    CommandMessage reply;
+    reply.setReplyRejected(CommandMessage::UNKNOWN_COMMAND, commandMessage.getCommand());
+    requestQueue->reply(&reply);
+    return;
+  }
+}

mission/com/TmStoreTaskBase.h

@@ -1,15 +1,22 @@
 #ifndef MISSION_TMTC_TMSTORETASKBASE_H_
 #define MISSION_TMTC_TMSTORETASKBASE_H_
 
+#include <fsfw/modes/HasModesIF.h>
+#include <fsfw/subsystem/ModeTreeChildIF.h>
+#include <fsfw/subsystem/ModeTreeConnectionIF.h>
+#include <fsfw/timemanager/CdsShortTimeStamper.h>
 #include <fsfw/timemanager/Countdown.h>
+#include <mission/com/VirtualChannel.h>
 #include <mission/tmtc/PersistentTmStoreWithTmQueue.h>
-#include <mission/tmtc/VirtualChannel.h>
 
 /**
  * Generic class which composes a Virtual Channel and a persistent TM stores. This allows dumping
  * the TM store into the virtual channel directly.
  */
-class TmStoreTaskBase : public SystemObject {
+class TmStoreTaskBase : public SystemObject,
+                        public HasModesIF,
+                        public ModeTreeChildIF,
+                        public ModeTreeConnectionIF {
  public:
   struct DumpContext {
     DumpContext(Event eventIfDone, Event eventIfCancelled)
@@ -33,19 +40,35 @@ class TmStoreTaskBase : public SystemObject {
   };
 
   TmStoreTaskBase(object_id_t objectId, StorageManagerIF& ipcStore, VirtualChannel& channel,
-                  SdCardMountedIF& sdcMan);
+                  SdCardMountedIF& sdcMan, const std::atomic_bool& ptmeLocked);
+
+  ReturnValue_t initialize() override;
+  ReturnValue_t connectModeTreeParent(HasModeTreeChildrenIF& parent) override;
 
  protected:
+  ModeHelper modeHelper;
+  MessageQueueIF* requestQueue;
   StorageManagerIF& ipcStore;
+  PusTmReader tmReader;
+  CdsShortTimeStamper timeReader;
+  VirtualChannel& channel;
+  SdCardMountedIF& sdcMan;
+  const std::atomic_bool& ptmeLocked;
+
+  Mode_t mode = HasModesIF::MODE_OFF;
   Countdown sdCardCheckCd = Countdown(800);
   // 20 minutes are allowed as maximum dump time.
   Countdown cancelDumpCd = Countdown(60 * 20 * 1000);
   // If the TM sink is busy for 1 minute for whatever reason, cancel the dump.
   Countdown tmSinkBusyCd = Countdown(60 * 1000);
-  VirtualChannel& channel;
+
   bool storesInitialized = false;
   bool fileHasSwapped = false;
-  SdCardMountedIF& sdcMan;
+
+  void readCommandQueue(void);
+
+  virtual bool initStoresIfPossible() = 0;
+  virtual void startTransition(Mode_t mode, Submode_t submode) = 0;
 
   void cancelDump(DumpContext& ctx, PersistentTmStore& store, bool isTxOn);
   /**
@@ -58,6 +81,8 @@ class TmStoreTaskBase : public SystemObject {
 
   ReturnValue_t handleOneDump(PersistentTmStoreWithTmQueue& store, DumpContext& dumpContext,
                               bool& dumpPerformed);
+  ReturnValue_t performDump(PersistentTmStoreWithTmQueue& store, DumpContext& dumpContext,
+                            bool& dumpPerformed);
 
   /**
    * Occasionally check whether SD card is okay to be used. If not, poll whether it is ready to
@@ -65,7 +90,17 @@ class TmStoreTaskBase : public SystemObject {
    */
   bool cyclicStoreCheck();
 
-  virtual bool initStoresIfPossible() = 0;
+  MessageQueueId_t getCommandQueue() const override;
+
+  void getMode(Mode_t* mode, Submode_t* submode) override;
+
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t* msToReachTheMode) override;
+  void announceMode(bool recursive) override;
+  object_id_t getObjectId() const override;
+  const HasHealthIF* getOptHealthIF() const override;
+  const HasModesIF& getModeIF() const override;
+  ModeTreeChildIF& getModeTreeChildIF() override;
 };
 
 #endif /* MISSION_TMTC_TMSTORETASKBASE_H_ */

mission/com/VirtualChannelWithQueue.cpp

@@ -1,4 +1,4 @@
-#include <mission/tmtc/VirtualChannelWithQueue.h>
+#include "VirtualChannelWithQueue.h"
 
 #include "OBSWConfig.h"
 #include "fsfw/ipc/QueueFactory.h"
@@ -19,7 +19,7 @@ VirtualChannelWithQueue::VirtualChannelWithQueue(object_id_t objectId, uint8_t v
 
 const char* VirtualChannelWithQueue::getName() const { return VirtualChannel::getName(); }
 
-ReturnValue_t VirtualChannelWithQueue::sendNextTm() {
+ReturnValue_t VirtualChannelWithQueue::handleNextTm(bool performWriteOp) {
   TmTcMessage message;
   ReturnValue_t result = tmQueue->receiveMessage(&message);
   if (result == MessageQueueIF::EMPTY) {
@@ -36,7 +36,9 @@ ReturnValue_t VirtualChannelWithQueue::sendNextTm() {
     return result;
   }
 
-  result = write(data, size);
+  if (performWriteOp) {
+    result = write(data, size);
+  }
   // Try delete in any case, ignore failures (which should not happen), it is more important to
   // propagate write errors.
   tmStore.deleteData(storeId);

mission/com/VirtualChannelWithQueue.h

@@ -4,7 +4,7 @@
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/tasks/ExecutableObjectIF.h>
 #include <linux/ipcore/PtmeIF.h>
-#include <mission/tmtc/VirtualChannel.h>
+#include <mission/com/VirtualChannel.h>
 
 #include <atomic>
 
@@ -34,7 +34,7 @@ class VirtualChannelWithQueue : public VirtualChannel, public AcceptsTelemetryIF
 
   MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) const override;
   [[nodiscard]] const char* getName() const override;
-  ReturnValue_t sendNextTm();
+  ReturnValue_t handleNextTm(bool performWriteOp);
 
  private:
   MessageQueueIF* tmQueue = nullptr;

mission/config/comCfg.cpp

@@ -3,6 +3,8 @@
 #include <fsfw/ipc/MutexFactory.h>
 #include <fsfw/ipc/MutexGuard.h>
 
+#include <atomic>
+
 com::Datarate DATARATE_CFG_RAW = com::Datarate::LOW_RATE_MODULATION_BPSK;
 MutexIF* DATARATE_LOCK = nullptr;
 

mission/genericFactory.cpp

@@ -192,8 +192,8 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
 
   // HK store and PUS funnel to HK store routing
   {
-    PersistentTmStoreArgs storeArgs(objects::HK_TM_STORE, "tm", "hk", RolloverInterval::MINUTELY,
-                                    15, *ramToFileStore, sdcMan);
+    PersistentTmStoreArgs storeArgs(objects::HK_TM_STORE, "tm", "hk", RolloverInterval::MINUTELY, 2,
+                                    *ramToFileStore, sdcMan);
     stores.hkStore =
         new PersistentTmStoreWithTmQueue(storeArgs, "HK STORE", config::HK_STORE_QUEUE_SIZE);
     (*pusFunnel)
@@ -347,7 +347,8 @@ void ObjectFactory::createAcsBoardAssy(PowerSwitchIF& pwrSwitcher,
   AcsBoardHelper acsBoardHelper = AcsBoardHelper(
       objects::MGM_0_LIS3_HANDLER, objects::MGM_1_RM3100_HANDLER, objects::MGM_2_LIS3_HANDLER,
       objects::MGM_3_RM3100_HANDLER, objects::GYRO_0_ADIS_HANDLER, objects::GYRO_1_L3G_HANDLER,
-      objects::GYRO_2_ADIS_HANDLER, objects::GYRO_3_L3G_HANDLER, objects::GPS_CONTROLLER);
+      objects::GYRO_2_ADIS_HANDLER, objects::GYRO_3_L3G_HANDLER, objects::GPS_CONTROLLER,
+      objects::GPS_0_HEALTH_DEV, objects::GPS_1_HEALTH_DEV);
   auto acsAss =
       new AcsBoardAssembly(objects::ACS_BOARD_ASS, &pwrSwitcher, acsBoardHelper, gpioComIF);
   for (auto& assChild : assemblyDhbs) {

mission/payload/ScexDeviceHandler.cpp

@@ -11,6 +11,7 @@
 #include <iostream>
 #include <random>
 
+#include "eive/definitions.h"
 #include "fsfw/globalfunctions/CRC.h"
 
 using std::ofstream;
@@ -27,6 +28,7 @@ void ScexDeviceHandler::doStartUp() { setMode(MODE_ON); }
 void ScexDeviceHandler::doShutDown() {
   reader.reset();
   commandActive = false;
+  fileNameSet = false;
   multiFileFinishOutstanding = false;
   setMode(_MODE_POWER_DOWN);
 }
@@ -205,50 +207,13 @@ ReturnValue_t ScexDeviceHandler::interpretDeviceReply(DeviceCommandId_t id, cons
   using namespace scex;
 
   ReturnValue_t status = OK;
-  auto oneFileHandler = [&](std::string cmdName) {
-    auto activeSd = sdcMan.getActiveSdCard();
-    if (not activeSd) {
-      return HasFileSystemIF::FILESYSTEM_INACTIVE;
-    }
-    fileId = date_time_string();
-    std::ostringstream oss;
-    auto prefix = sdcMan.getCurrentMountPrefix();
-    if (prefix == nullptr) {
-      return returnvalue::FAILED;
-    }
-    oss << prefix << "/scex/scex-" << cmdName << fileId << ".bin";
-    fileName = oss.str();
-    ofstream out(fileName, ofstream::binary);
-    if (out.bad()) {
-      sif::error << "ScexDeviceHandler::interpretDeviceReply: Could not open file " << fileName
-                 << std::endl;
-      return FAILED;
-    }
-    out << helper;
-    return OK;
-  };
-  auto multiFileHandler = [&](std::string cmdName) {
+  auto multiFileHandler = [&](const char* cmdName) {
     if ((helper.getPacketCounter() == 1) or (not fileNameSet)) {
-      auto activeSd = sdcMan.getActiveSdCard();
-      if (not activeSd) {
-        return HasFileSystemIF::FILESYSTEM_INACTIVE;
+      status = generateNewScexFile(cmdName);
+      if (status != returnvalue::OK) {
+        return status;
       }
-      fileId = date_time_string();
-      std::ostringstream oss;
-      auto prefix = sdcMan.getCurrentMountPrefix();
-      if (prefix == nullptr) {
-        return returnvalue::FAILED;
-      }
-      oss << prefix << "/scex/scex-" << cmdName << fileId << ".bin";
-      fileName = oss.str();
       fileNameSet = true;
-      ofstream out(fileName, ofstream::binary);
-      if (out.bad()) {
-        sif::error << "ScexDeviceHandler::handleValidReply: Could not open file " << fileName
-                   << std::endl;
-        return FAILED;
-      }
-      out << helper;
     } else {
       ofstream out(fileName,
                    ofstream::binary | ofstream::app);  // append
@@ -264,31 +229,31 @@ ReturnValue_t ScexDeviceHandler::interpretDeviceReply(DeviceCommandId_t id, cons
   id = helper.getCmd();
   switch (id) {
     case (PING): {
-      status = oneFileHandler("ping_");
+      status = generateNewScexFile(PING_IDLE_BASE_NAME);
       break;
     }
     case (ION_CMD): {
-      status = oneFileHandler("ion_");
+      status = generateNewScexFile(ION_BASE_NAME);
       break;
     }
     case (TEMP_CMD): {
-      status = oneFileHandler("temp_");
+      status = generateNewScexFile(TEMPERATURE_BASE_NAME);
       break;
     }
     case (EXP_STATUS_CMD): {
-      status = oneFileHandler("exp_status_");
+      status = generateNewScexFile(EXP_STATUS_BASE_NAME);
       break;
     }
     case (FRAM): {
-      status = multiFileHandler("fram_");
+      status = multiFileHandler(FRAM_BASE_NAME);
       break;
     }
     case (ONE_CELL): {
-      status = multiFileHandler("one_cell_");
+      status = multiFileHandler(ONE_CELL_BASE_NAME);
       break;
     }
     case (ALL_CELLS_CMD): {
-      status = multiFileHandler("multi_cell_");
+      status = multiFileHandler(ALL_CELLS_BASE_NAME);
       break;
     }
     default:
@@ -354,37 +319,41 @@ ReturnValue_t ScexDeviceHandler::initializeLocalDataPool(localpool::DataPool& lo
   return OK;
 }
 
-std::string ScexDeviceHandler::date_time_string() {
-  using namespace std;
-  string date_time;
-  Clock::TimeOfDay_t tod;
-  Clock::getDateAndTime(&tod);
-  ostringstream oss(std::ostringstream::ate);
-
-  if (tod.hour < 10) {
-    oss << tod.year << tod.month << tod.day << "_0" << tod.hour;
-  } else {
-    oss << tod.year << tod.month << tod.day << "_" << tod.hour;
-  }
-  if (tod.minute < 10) {
-    oss << 0 << tod.minute;
-
-  } else {
-    oss << tod.minute;
-  }
-  if (tod.second < 10) {
-    oss << 0 << tod.second;
-  } else {
-    oss << tod.second;
+ReturnValue_t ScexDeviceHandler::generateNewScexFile(const char* cmdName) {
+  char timeString[64]{};
+  auto activeSd = sdcMan.getActiveSdCard();
+  if (not activeSd) {
+    return HasFileSystemIF::FILESYSTEM_INACTIVE;
   }
 
-  date_time = oss.str();
-
-  return date_time;
+  std::ostringstream oss;
+  auto prefix = sdcMan.getCurrentMountPrefix();
+  if (prefix == nullptr) {
+    return returnvalue::FAILED;
+  }
+  timeval tv;
+  Clock::getClock_timeval(&tv);
+  time_t epoch = tv.tv_sec;
+  struct tm* time = gmtime(&epoch);
+  size_t writtenBytes = strftime(reinterpret_cast<char*>(timeString), sizeof(timeString),
+                                 config::FILE_DATE_FORMAT, time);
+  if (writtenBytes == 0) {
+    sif::error << "PersistentTmStore::createMostRecentFile: Could not create file timestamp"
+               << std::endl;
+    return returnvalue::FAILED;
+  }
+  oss << prefix << "/scex/scex-" << cmdName << "-" << timeString << ".bin";
+  fileName = oss.str();
+  ofstream out(fileName, ofstream::binary);
+  if (out.bad()) {
+    sif::error << "ScexDeviceHandler::interpretDeviceReply: Could not open file " << fileName
+               << std::endl;
+    return FAILED;
+  }
+  out << helper;
+  return OK;
 }
 
-void ScexDeviceHandler::modeChanged() {}
-
 void ScexDeviceHandler::setPowerSwitcher(PowerSwitchIF& powerSwitcher, power::Switch_t switchId) {
   DeviceHandlerBase::setPowerSwitcher(&powerSwitcher);
   this->switchId = switchId;

mission/payload/ScexDeviceHandler.h

@@ -13,6 +13,14 @@ class SdCardMountedIF;
 
 class ScexDeviceHandler : public DeviceHandlerBase {
  public:
+  static constexpr char FRAM_BASE_NAME[] = "framContent";
+  static constexpr char ION_BASE_NAME[] = "ion";
+  static constexpr char TEMPERATURE_BASE_NAME[] = "temperature";
+  static constexpr char EXP_STATUS_BASE_NAME[] = "expStatus";
+  static constexpr char ONE_CELL_BASE_NAME[] = "oneCell";
+  static constexpr char ALL_CELLS_BASE_NAME[] = "allCells";
+  static constexpr char PING_IDLE_BASE_NAME[] = "pingIdle";
+
   ScexDeviceHandler(object_id_t objectId, ScexUartReader &reader, CookieIF *cookie,
                     SdCardMountedIF &sdcMan);
   void setPowerSwitcher(PowerSwitchIF &powerSwitcher, power::Switch_t switchId);
@@ -35,8 +43,6 @@ class ScexDeviceHandler : public DeviceHandlerBase {
   SdCardMountedIF &sdcMan;
   Countdown finishCountdown = Countdown(LONG_CD);
 
-  std::string date_time_string();
-
   // DeviceHandlerBase private function implementation
   void doStartUp() override;
   void doShutDown() override;
@@ -59,7 +65,8 @@ class ScexDeviceHandler : public DeviceHandlerBase {
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
   ReturnValue_t initializeAfterTaskCreation() override;
-  void modeChanged() override;
+
+  ReturnValue_t generateNewScexFile(const char *cmdName);
 };
 
 #endif /* MISSION_PAYLOAD_SCEXDEVICEHANDLER_H_ */

mission/pollingSeqTables.cpp

@@ -26,10 +26,12 @@ ReturnValue_t pst::pstSyrlinks(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
   thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
   thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4,
+                        DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4, DeviceHandlerIF::SEND_WRITE);
   thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.7, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.75, DeviceHandlerIF::GET_READ);
 
   static_cast<void>(length);
 
@@ -102,25 +104,50 @@ ReturnValue_t pst::pstGompaceCan(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
 
-  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
 
-  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
 
-  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.25, DeviceHandlerIF::SEND_READ);
 
-  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.25, DeviceHandlerIF::GET_READ);
+
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.5, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.5, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.5, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.5, DeviceHandlerIF::PERFORM_OPERATION);
+
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.5, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.5, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.5, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.5, DeviceHandlerIF::SEND_WRITE);
+
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.5, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.5, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.5, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.5, DeviceHandlerIF::GET_WRITE);
+
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
+
+  thisSequence->addSlot(objects::P60DOCK_HANDLER, length * 0.75, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::PDU1_HANDLER, length * 0.75, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::PDU2_HANDLER, length * 0.75, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::ACU_HANDLER, length * 0.75, DeviceHandlerIF::GET_READ);
   if (thisSequence->checkSequence() != returnvalue::OK) {
     sif::error << "GomSpace PST initialization failed" << std::endl;
     return returnvalue::FAILED;

mission/system/acs/AcsBoardAssembly.cpp

@@ -77,14 +77,16 @@ ReturnValue_t AcsBoardAssembly::checkChildrenStateOn(Mode_t wantedMode, Submode_
   if (wantedSubmode == A_SIDE) {
     if ((helper.gyro0SideAMode != wantedMode and helper.gyro1SideAMode != wantedMode) or
         (helper.mgm0SideAMode != wantedMode and helper.mgm1SideAMode != wantedMode) or
-        helper.gpsMode != MODE_ON) {
+        (helper.gpsMode != MODE_ON) or
+        (healthHelper.healthTable->getHealth(helper.healthDevGps0) == FAULTY)) {
       return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
     }
     return returnvalue::OK;
   } else if (wantedSubmode == B_SIDE) {
     if ((helper.gyro2SideBMode != wantedMode and helper.gyro3SideBMode != wantedMode) or
         (helper.mgm2SideBMode != wantedMode and helper.mgm3SideBMode != wantedMode) or
-        helper.gpsMode != MODE_ON) {
+        (helper.gpsMode != MODE_ON) or
+        (healthHelper.healthTable->getHealth(helper.healthDevGps1) == FAULTY)) {
       return NOT_ENOUGH_CHILDREN_IN_CORRECT_STATE;
     }
     return returnvalue::OK;
@@ -110,28 +112,37 @@ ReturnValue_t AcsBoardAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t s
   using namespace duallane;
   ReturnValue_t result = returnvalue::OK;
   bool needsSecondStep = false;
-  if (sideSwitchState == SideSwitchState::REQUESTED) {
-    sideSwitchState = SideSwitchState::TO_DUAL;
-  }
-  // Switch to dual side first, and later switch back to the otherside
-  if (sideSwitchState == SideSwitchState::TO_DUAL) {
-    targetSubmodeForSideSwitch = static_cast<duallane::Submodes>(submode);
-    submode = Submodes::DUAL_MODE;
-    sideSwitchState = SideSwitchState::DISABLE_OTHER_SIDE;
-    // TODO: Ugly hack. The base class should support arbitrary number of steps..
-    needsSecondStep = true;
-  } else if (sideSwitchState == SideSwitchState::DISABLE_OTHER_SIDE) {
-    submode = targetSubmodeForSideSwitch;
-  }
+  handleSideSwitchStates(submode, needsSecondStep);
   auto cmdSeq = [&](object_id_t objectId, Mode_t devMode, ModeTableIdx tableIdx) {
     if (mode == devMode) {
       modeTable[tableIdx].setMode(mode);
-    } else if (isUseable(objectId, devMode)) {
+    } else if (isModeCommandable(objectId, devMode)) {
       modeTable[tableIdx].setMode(mode);
       modeTable[tableIdx].setSubmode(SUBMODE_NONE);
     }
   };
-  bool gpsUsable = isUseable(helper.gpsId, helper.gpsMode);
+  bool gpsUsable = isModeCommandable(helper.gpsId, helper.gpsMode);
+  auto gpsCmd = [&](bool gnss0NReset, bool gnss1NReset, uint8_t gnssSelect) {
+    if (gpsUsable) {
+      if (mode == MODE_ON or mode == DeviceHandlerIF::MODE_NORMAL) {
+        modeTable[ModeTableIdx::GPS].setMode(MODE_ON);
+      } else if (mode == MODE_OFF) {
+        gnss0NReset = true;
+        gnss1NReset = true;
+        modeTable[ModeTableIdx::GPS].setMode(MODE_OFF);
+      }
+      modeTable[ModeTableIdx::GPS].setSubmode(SUBMODE_NONE);
+
+      gpioHandler(gpioIds::GNSS_0_NRESET, gnss0NReset,
+                  "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
+                  "of GNSS 0");
+      gpioHandler(gpioIds::GNSS_1_NRESET, gnss1NReset,
+                  "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
+                  "of GNSS 1");
+      gpioHandler(gpioIds::GNSS_SELECT, gnssSelect,
+                  "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull GNSS select");
+    }
+  };
   switch (submode) {
     case (A_SIDE): {
       modeTable[ModeTableIdx::GYRO_2_B].setMode(MODE_OFF);
@@ -146,16 +157,7 @@ ReturnValue_t AcsBoardAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t s
       cmdSeq(helper.gyro1L3gIdSideA, helper.gyro1SideAMode, ModeTableIdx::GYRO_1_A);
       cmdSeq(helper.mgm0Lis3IdSideA, helper.mgm0SideAMode, ModeTableIdx::MGM_0_A);
       cmdSeq(helper.mgm1Rm3100IdSideA, helper.mgm1SideAMode, ModeTableIdx::MGM_1_A);
-      if (gpsUsable) {
-        gpioHandler(gpioIds::GNSS_0_NRESET, true,
-                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
-                    "of GNSS 0 high (used GNSS)");
-        gpioHandler(gpioIds::GNSS_1_NRESET, false,
-                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
-                    "of GNSS 1 low (unused GNSS)");
-        gpioHandler(gpioIds::GNSS_SELECT, false,
-                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull GNSS select low");
-      }
+      gpsCmd(true, false, 0);
       break;
     }
     case (B_SIDE): {
@@ -171,20 +173,10 @@ ReturnValue_t AcsBoardAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t s
       cmdSeq(helper.gyro3L3gIdSideB, helper.gyro3SideBMode, ModeTableIdx::GYRO_3_B);
       cmdSeq(helper.mgm2Lis3IdSideB, helper.mgm2SideBMode, ModeTableIdx::MGM_2_B);
       cmdSeq(helper.mgm3Rm3100IdSideB, helper.mgm3SideBMode, ModeTableIdx::MGM_3_B);
-      if (gpsUsable) {
-        gpioHandler(gpioIds::GNSS_0_NRESET, false,
-                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
-                    "of GNSS 0 low (unused GNSS)");
-        gpioHandler(gpioIds::GNSS_1_NRESET, true,
-                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
-                    "of GNSS 1 high (used GNSS)");
-        gpioHandler(gpioIds::GNSS_SELECT, true,
-                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull GNSS select high");
-      }
+      gpsCmd(false, true, 1);
       break;
     }
     case (DUAL_MODE): {
-      cmdSeq(helper.gpsId, helper.gpsMode, ModeTableIdx::GPS);
       cmdSeq(helper.gyro0AdisIdSideA, helper.gyro0SideAMode, ModeTableIdx::GYRO_0_A);
       cmdSeq(helper.gyro1L3gIdSideA, helper.gyro1SideAMode, ModeTableIdx::GYRO_1_A);
       cmdSeq(helper.mgm0Lis3IdSideA, helper.mgm0SideAMode, ModeTableIdx::MGM_0_A);
@@ -193,26 +185,10 @@ ReturnValue_t AcsBoardAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t s
       cmdSeq(helper.gyro3L3gIdSideB, helper.gyro3SideBMode, ModeTableIdx::GYRO_3_B);
       cmdSeq(helper.mgm2Lis3IdSideB, helper.mgm2SideBMode, ModeTableIdx::MGM_2_B);
       cmdSeq(helper.mgm3Rm3100IdSideB, helper.mgm3SideBMode, ModeTableIdx::MGM_3_B);
-      ReturnValue_t status = returnvalue::OK;
-      if (gpsUsable) {
-        gpioHandler(gpioIds::GNSS_0_NRESET, true,
-                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
-                    "of GNSS 0 high (used GNSS)");
-        gpioHandler(gpioIds::GNSS_1_NRESET, true,
-                    "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull nReset pin"
-                    "of GNSS 1 high (used GNSS)");
-        if (defaultSubmode == Submodes::A_SIDE) {
-          status = gpioIF->pullLow(gpioIds::GNSS_SELECT);
-        } else {
-          status = gpioIF->pullHigh(gpioIds::GNSS_SELECT);
-        }
-        if (status != returnvalue::OK) {
-#if OBSW_VERBOSE_LEVEL >= 1
-          sif::error << "AcsBoardAssembly::handleNormalOrOnModeCmd: Could not pull GNSS select to"
-                        "default side for dual mode"
-                     << std::endl;
-#endif
-        }
+      if (defaultSubmode == Submodes::A_SIDE) {
+        gpsCmd(true, true, 0);
+      } else {
+        gpsCmd(true, true, 1);
       }
       break;
     }
@@ -220,10 +196,6 @@ ReturnValue_t AcsBoardAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t s
       sif::error << "AcsBoardAssembly::handleNormalModeCmd: Unknown submode" << std::endl;
     }
   }
-  if (gpsUsable) {
-    modeTable[ModeTableIdx::GPS].setMode(MODE_ON);
-    modeTable[ModeTableIdx::GPS].setSubmode(SUBMODE_NONE);
-  }
   if (needsSecondStep) {
     result = NEED_SECOND_STEP;
   }
@@ -307,6 +279,9 @@ ReturnValue_t AcsBoardAssembly::checkAndHandleHealthStates(Mode_t deviceMode,
       modeHelper.setForced(true);
     }
   };
+  if (healthHelper.healthTable->getHealth(helper.gpsId) == EXTERNAL_CONTROL) {
+    modeHelper.setForced(true);
+  }
   if (deviceSubmode == duallane::DUAL_MODE) {
     checkAcsBoardSensorGroup(helper.mgm0Lis3IdSideA, helper.mgm1Rm3100IdSideA,
                              helper.mgm2Lis3IdSideB, helper.mgm3Rm3100IdSideB);
@@ -315,3 +290,25 @@ ReturnValue_t AcsBoardAssembly::checkAndHandleHealthStates(Mode_t deviceMode,
   }
   return status;
 }
+
+void AcsBoardAssembly::handleChildrenLostMode(ReturnValue_t result) {
+  using namespace duallane;
+  // Special handling to account for GPS devices being faulty. If the GPS device on the other
+  // side is marked faulty, directly to to dual side.
+  if (submode == Submodes::A_SIDE) {
+    if (healthHelper.healthTable->getHealth(helper.healthDevGps1) == FAULTY or
+        healthHelper.healthTable->getHealth(helper.healthDevGps1) == PERMANENT_FAULTY) {
+      triggerEvent(DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY, submode, 0);
+      startTransition(mode, Submodes::DUAL_MODE);
+      return;
+    }
+  } else if (submode == Submodes::B_SIDE) {
+    if (healthHelper.healthTable->getHealth(helper.healthDevGps0) == FAULTY or
+        healthHelper.healthTable->getHealth(helper.healthDevGps0) == PERMANENT_FAULTY) {
+      triggerEvent(DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY, submode, 0);
+      startTransition(mode, Submodes::DUAL_MODE);
+      return;
+    }
+  }
+  DualLaneAssemblyBase::handleChildrenLostMode(result);
+}

mission/system/acs/AcsBoardAssembly.h

@@ -12,7 +12,7 @@
 struct AcsBoardHelper {
   AcsBoardHelper(object_id_t mgm0Id, object_id_t mgm1Id, object_id_t mgm2Id, object_id_t mgm3Id,
                  object_id_t gyro0Id, object_id_t gyro1Id, object_id_t gyro2Id, object_id_t gyro3Id,
-                 object_id_t gpsId)
+                 object_id_t gpsId, object_id_t gps0HealthDev, object_id_t gps1HealthDev)
       : mgm0Lis3IdSideA(mgm0Id),
         mgm1Rm3100IdSideA(mgm1Id),
         mgm2Lis3IdSideB(mgm2Id),
@@ -35,6 +35,9 @@ struct AcsBoardHelper {
 
   object_id_t gpsId = objects::NO_OBJECT;
 
+  object_id_t healthDevGps0 = objects::NO_OBJECT;
+  object_id_t healthDevGps1 = objects::NO_OBJECT;
+
   Mode_t gyro0SideAMode = HasModesIF::MODE_OFF;
   Mode_t gyro1SideAMode = HasModesIF::MODE_OFF;
   Mode_t gyro2SideBMode = HasModesIF::MODE_OFF;
@@ -91,6 +94,11 @@ class AcsBoardAssembly : public DualLaneAssemblyBase {
   //! desired mode/submode combination
   static constexpr Event SIDE_SWITCH_TRANSITION_NOT_ALLOWED =
       event::makeEvent(SUBSYSTEM_ID, 3, severity::LOW);
+  //! [EXPORT] : [COMMENT] This is triggered when the assembly would have normally switched
+  //! the board side, but the GPS device of the other side was marked faulty.
+  //! P1: Current submode.
+  static constexpr Event DIRECT_TRANSITION_TO_DUAL_OTHER_GPS_FAULTY =
+      event::makeEvent(SUBSYSTEM_ID, 4, severity::MEDIUM);
 
   static constexpr uint8_t NUMBER_DEVICES_MODE_TABLE = 9;
 
@@ -120,6 +128,8 @@ class AcsBoardAssembly : public DualLaneAssemblyBase {
   ReturnValue_t commandChildren(Mode_t mode, Submode_t submode) override;
   ReturnValue_t checkChildrenStateOn(Mode_t wantedMode, Submode_t wantedSubmode) override;
 
+  void handleChildrenLostMode(ReturnValue_t result) override;
+
   ReturnValue_t handleNormalOrOnModeCmd(Mode_t mode, Submode_t submode);
   ReturnValue_t checkAndHandleHealthStates(Mode_t deviceMode, Submode_t deviceSubmode);
   void refreshHelperModes();

mission/system/acs/CMakeLists.txt

@@ -2,6 +2,7 @@ target_sources(
   ${LIB_EIVE_MISSION}
   PRIVATE AcsBoardAssembly.cpp
           AcsSubsystem.cpp
+          StrAssembly.cpp
           DualLaneAssemblyBase.cpp
           ImtqAssembly.cpp
           RwAssembly.cpp

mission/system/acs/DualLaneAssemblyBase.cpp

@@ -46,6 +46,9 @@ void DualLaneAssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
       AssemblyBase::startTransition(mode, submode);
       return;
     }
+    if (sideSwitchState == SideSwitchState::NONE and sideSwitchTransition(mode, submode)) {
+      sideSwitchState = SideSwitchState::REQUESTED;
+    }
     uint8_t pwrSubmode = submode;
     if (sideSwitchState == SideSwitchState::REQUESTED) {
       pwrSubmode = duallane::DUAL_MODE;
@@ -61,7 +64,7 @@ void DualLaneAssemblyBase::startTransition(Mode_t mode, Submode_t submode) {
   }
 }
 
-bool DualLaneAssemblyBase::isUseable(object_id_t object, Mode_t mode) {
+bool DualLaneAssemblyBase::isModeCommandable(object_id_t object, Mode_t mode) {
   if (healthHelper.healthTable->isFaulty(object)) {
     return false;
   }
@@ -70,10 +73,7 @@ bool DualLaneAssemblyBase::isUseable(object_id_t object, Mode_t mode) {
   if (childrenMap[object].mode == mode) {
     return true;
   }
-
-  if (healthHelper.healthTable->isCommandable(object)) {
-    return true;
-  }
+  // Check for external control health state is done by base class.
   return false;
 }
 
@@ -115,9 +115,6 @@ ReturnValue_t DualLaneAssemblyBase::isModeCombinationValid(Mode_t mode, Submode_
   if (submode != A_SIDE and submode != B_SIDE and submode != DUAL_MODE) {
     return returnvalue::FAILED;
   }
-  if (sideSwitchTransition(mode, submode)) {
-    sideSwitchState = SideSwitchState::REQUESTED;
-  }
   return returnvalue::OK;
 }
 
@@ -133,7 +130,11 @@ void DualLaneAssemblyBase::handleModeReached() {
     // For dual to single side transition, devices should be logically off, but the switch
     // handling still needs to be done.
     if (dualToSingleSideTransition) {
-      pwrStateMachine.start(targetMode, targetSubmode);
+      if (sideSwitchState == SideSwitchState::DISABLE_OTHER_SIDE) {
+        pwrStateMachine.start(targetMode, targetSubmodeForSideSwitch);
+      } else {
+        pwrStateMachine.start(targetMode, targetSubmode);
+      }
       pwrStateMachineWrapper();
       return;
     }
@@ -241,6 +242,24 @@ bool DualLaneAssemblyBase::sideSwitchTransition(Mode_t mode, Submode_t submode)
   return false;
 }
 
+void DualLaneAssemblyBase::handleSideSwitchStates(uint8_t& submode, bool& needsSecondStep) {
+  if (sideSwitchState == SideSwitchState::REQUESTED) {
+    sideSwitchState = SideSwitchState::TO_DUAL;
+  }
+  // Switch to dual side first, and later switch back to the otherside
+  if (sideSwitchState == SideSwitchState::TO_DUAL) {
+    targetSubmodeForSideSwitch = static_cast<duallane::Submodes>(submode);
+    submode = duallane::Submodes::DUAL_MODE;
+    sideSwitchState = SideSwitchState::DISABLE_OTHER_SIDE;
+    // TODO: Ugly hack. The base class should support arbitrary number of steps..
+    needsSecondStep = true;
+  } else if (sideSwitchState == SideSwitchState::DISABLE_OTHER_SIDE) {
+    // Set this flag because the power needs to be switched off.
+    dualToSingleSideTransition = true;
+    submode = targetSubmodeForSideSwitch;
+  }
+}
+
 void DualLaneAssemblyBase::finishModeOp() {
   using namespace duallane;
   AssemblyBase::handleModeReached();

mission/system/acs/DualLaneAssemblyBase.h

@@ -49,12 +49,19 @@ class DualLaneAssemblyBase : public AssemblyBase, public ConfirmsFailuresIF {
   MessageQueueIF* eventQueue = nullptr;
 
   /**
-   * Check whether it makes sense to send mode commands to the device
+   * To be called in mode command packer function of the child class.
+   * @param submode
+   * @param needsSecondStep
+   */
+  void handleSideSwitchStates(uint8_t& submode, bool& needsSecondStep);
+
+  /**
+   * Check whether it makes sense to send mode commands to the device.
    * @param object
    * @param mode
    * @return
    */
-  bool isUseable(object_id_t object, Mode_t mode);
+  bool isModeCommandable(object_id_t object, Mode_t mode);
 
   /**
    * Thin wrapper function which is required because the helper class

mission/system/acs/SusAssembly.cpp

@@ -45,6 +45,7 @@ ReturnValue_t SusAssembly::handleNormalOrOnModeCmd(Mode_t mode, Submode_t submod
   using namespace duallane;
   ReturnValue_t result = returnvalue::OK;
   bool needsSecondStep = false;
+  handleSideSwitchStates(submode, needsSecondStep);
   auto cmdSeq = [&](object_id_t objectId, Mode_t devMode, uint8_t tableIdx) {
     if (mode == devMode) {
       modeTable[tableIdx].setMode(mode);

mission/system/com/comModeTree.cpp

@@ -22,7 +22,7 @@ auto COM_SEQUENCE_RX_ONLY =
 auto COM_TABLE_RX_ONLY_TGT = std::make_pair(
     static_cast<uint32_t>(::com::Submode::RX_ONLY << 24) | 1, FixedArrayList<ModeListEntry, 3>());
 auto COM_TABLE_RX_ONLY_TRANS_0 = std::make_pair(
-    static_cast<uint32_t>(::com::Submode::RX_ONLY << 24) | 2, FixedArrayList<ModeListEntry, 3>());
+    static_cast<uint32_t>(::com::Submode::RX_ONLY << 24) | 2, FixedArrayList<ModeListEntry, 6>());
 auto COM_TABLE_RX_ONLY_TRANS_1 = std::make_pair(
     static_cast<uint32_t>(::com::Submode::RX_ONLY << 24) | 3, FixedArrayList<ModeListEntry, 3>());
 
@@ -36,7 +36,7 @@ auto COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_0 =
                    FixedArrayList<ModeListEntry, 3>());
 auto COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1 =
     std::make_pair(static_cast<uint32_t>(::com::Submode::RX_AND_TX_LOW_DATARATE << 24) | 3,
-                   FixedArrayList<ModeListEntry, 3>());
+                   FixedArrayList<ModeListEntry, 6>());
 
 auto COM_SEQUENCE_RX_AND_TX_HIGH_RATE =
     std::make_pair(::com::Submode::RX_AND_TX_HIGH_DATARATE, FixedArrayList<ModeListEntry, 3>());
@@ -48,7 +48,7 @@ auto COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_0 =
                    FixedArrayList<ModeListEntry, 3>());
 auto COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1 =
     std::make_pair(static_cast<uint32_t>(::com::Submode::RX_AND_TX_HIGH_DATARATE << 24) | 3,
-                   FixedArrayList<ModeListEntry, 3>());
+                   FixedArrayList<ModeListEntry, 6>());
 
 auto COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE =
     std::make_pair(::com::Submode::RX_AND_TX_DEFAULT_DATARATE, FixedArrayList<ModeListEntry, 3>());
@@ -60,7 +60,7 @@ auto COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_0 =
                    FixedArrayList<ModeListEntry, 3>());
 auto COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1 =
     std::make_pair(static_cast<uint32_t>(::com::Submode::RX_AND_TX_DEFAULT_DATARATE << 24) | 3,
-                   FixedArrayList<ModeListEntry, 3>());
+                   FixedArrayList<ModeListEntry, 6>());
 
 namespace {
 
@@ -110,6 +110,10 @@ void buildRxOnlySequence(Subsystem& ss, ModeListEntry& eh) {
 
   // Build RX Only transition 0
   iht(objects::SYRLINKS_ASSY, NML, ::com::Submode::RX_ONLY, COM_TABLE_RX_ONLY_TRANS_0.second);
+  iht(objects::LOG_STORE_AND_TM_TASK, OFF, 0, COM_TABLE_RX_ONLY_TRANS_0.second);
+  iht(objects::HK_STORE_AND_TM_TASK, OFF, 0, COM_TABLE_RX_ONLY_TRANS_0.second);
+  iht(objects::CFDP_STORE_AND_TM_TASK, OFF, 0, COM_TABLE_RX_ONLY_TRANS_0.second);
+  iht(objects::LIVE_TM_TASK, OFF, 0, COM_TABLE_RX_ONLY_TRANS_0.second);
   check(ss.addTable(TableEntry(COM_TABLE_RX_ONLY_TRANS_0.first, &COM_TABLE_RX_ONLY_TRANS_0.second)),
         ctxc);
 
@@ -165,6 +169,10 @@ void buildTxAndRxLowRateSequence(Subsystem& ss, ModeListEntry& eh) {
   // Build TX and RX low transition 1
   iht(objects::SYRLINKS_ASSY, NML, ::com::Submode::RX_AND_TX_LOW_DATARATE,
       COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.second);
+  iht(objects::LOG_STORE_AND_TM_TASK, ON, 0, COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.second);
+  iht(objects::HK_STORE_AND_TM_TASK, ON, 0, COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.second);
+  iht(objects::CFDP_STORE_AND_TM_TASK, ON, 0, COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.second);
+  iht(objects::LIVE_TM_TASK, ON, 0, COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.second);
   check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.first,
                                &COM_TABLE_RX_AND_TX_LOW_RATE_TRANS_1.second)),
         ctxc);
@@ -217,6 +225,10 @@ void buildTxAndRxHighRateSequence(Subsystem& ss, ModeListEntry& eh) {
   // Build TX and RX high transition 1
   iht(objects::SYRLINKS_ASSY, NML, ::com::Submode::RX_AND_TX_HIGH_DATARATE,
       COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.second);
+  iht(objects::LOG_STORE_AND_TM_TASK, ON, 0, COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.second);
+  iht(objects::HK_STORE_AND_TM_TASK, ON, 0, COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.second);
+  iht(objects::CFDP_STORE_AND_TM_TASK, ON, 0, COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.second);
+  iht(objects::LIVE_TM_TASK, ON, 0, COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.second);
   check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.first,
                                &COM_TABLE_RX_AND_TX_HIGH_RATE_TRANS_1.second)),
         ctxc);
@@ -271,6 +283,10 @@ void buildTxAndRxDefaultRateSequence(Subsystem& ss, ModeListEntry& eh) {
   // Build TX and RX default transition 1
   iht(objects::SYRLINKS_ASSY, NML, ::com::Submode::RX_AND_TX_DEFAULT_DATARATE,
       COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.second);
+  iht(objects::LOG_STORE_AND_TM_TASK, ON, 0, COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.second);
+  iht(objects::HK_STORE_AND_TM_TASK, ON, 0, COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.second);
+  iht(objects::CFDP_STORE_AND_TM_TASK, ON, 0, COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.second);
+  iht(objects::LIVE_TM_TASK, ON, 0, COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.second);
   check(ss.addTable(TableEntry(COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.first,
                                &COM_TABLE_RX_AND_TX_DEFAULT_RATE_TRANS_1.second)),
         ctxc);

mission/system/objects/CMakeLists.txt

@@ -5,6 +5,5 @@ target_sources(
           TcsSubsystem.cpp
           PayloadSubsystem.cpp
           Stack5VHandler.cpp
-          StrAssembly.cpp
           PowerStateMachineBase.cpp
           TcsBoardAssembly.cpp)

mission/tmtc/CMakeLists.txt

@@ -1,17 +1,11 @@
 target_sources(
   ${LIB_EIVE_MISSION}
-  PRIVATE VirtualChannelWithQueue.cpp
-          PersistentTmStoreWithTmQueue.cpp
-          LiveTmTask.cpp
-          VirtualChannel.cpp
+  PRIVATE PersistentTmStoreWithTmQueue.cpp
           TmFunnelHandler.cpp
           TmFunnelBase.cpp
           CfdpTmFunnel.cpp
           tmFilters.cpp
           PusLiveDemux.cpp
-          PersistentSingleTmStoreTask.cpp
-          PersistentLogTmStoreTask.cpp
-          TmStoreTaskBase.cpp
           PusPacketFilter.cpp
           PusTmRouteByFilterHelper.cpp
           Service15TmStorage.cpp

mission/tmtc/LiveTmTask.cpp

@@ -1,27 +0,0 @@
-#include "LiveTmTask.h"
-
-#include <fsfw/tasks/TaskFactory.h>
-#include <fsfw/timemanager/Stopwatch.h>
-
-LiveTmTask::LiveTmTask(object_id_t objectId, PusTmFunnel& pusFunnel, CfdpTmFunnel& cfdpFunnel,
-                       VirtualChannelWithQueue& channel)
-    : SystemObject(objectId), pusFunnel(pusFunnel), cfdpFunnel(cfdpFunnel), channel(channel) {}
-
-ReturnValue_t LiveTmTask::performOperation(uint8_t opCode) {
-  while (true) {
-    // The funnel tasks are scheduled here directly as well.
-    ReturnValue_t result = channel.sendNextTm();
-    if (result == DirectTmSinkIF::IS_BUSY) {
-      sif::error << "Lost live TM, PAPB busy" << std::endl;
-    }
-    if (result == MessageQueueIF::EMPTY) {
-      if (tmFunnelCd.hasTimedOut()) {
-        pusFunnel.performOperation(0);
-        cfdpFunnel.performOperation(0);
-        tmFunnelCd.resetTimer();
-      }
-      // 40 ms IDLE delay. Might tweak this in the future.
-      TaskFactory::delayTask(40);
-    }
-  }
-}

mission/tmtc/LiveTmTask.h

@@ -1,25 +0,0 @@
-#ifndef MISSION_TMTC_LIVETMTASK_H_
-#define MISSION_TMTC_LIVETMTASK_H_
-
-#include <fsfw/objectmanager/SystemObject.h>
-#include <fsfw/tasks/ExecutableObjectIF.h>
-#include <fsfw/timemanager/Countdown.h>
-#include <mission/tmtc/CfdpTmFunnel.h>
-#include <mission/tmtc/PusTmFunnel.h>
-#include <mission/tmtc/VirtualChannelWithQueue.h>
-
-class LiveTmTask : public SystemObject, public ExecutableObjectIF {
- public:
-  LiveTmTask(object_id_t objectId, PusTmFunnel& pusFunnel, CfdpTmFunnel& cfdpFunnel,
-             VirtualChannelWithQueue& channel);
-
-  ReturnValue_t performOperation(uint8_t opCode) override;
-
- private:
-  Countdown tmFunnelCd = Countdown(100);
-  PusTmFunnel& pusFunnel;
-  CfdpTmFunnel& cfdpFunnel;
-  VirtualChannelWithQueue& channel;
-};
-
-#endif /* MISSION_TMTC_LIVETMTASK_H_ */

mission/tmtc/PersistentTmStore.cpp

@@ -9,6 +9,7 @@
 #include <fstream>
 #include <utility>
 
+#include "eive/definitions.h"
 #include "fsfw/ipc/CommandMessage.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/tmstorage/TmStoreMessage.h"
@@ -251,41 +252,37 @@ ReturnValue_t PersistentTmStore::loadNextDumpFile() {
   return DUMP_DONE;
 }
 
-ReturnValue_t PersistentTmStore::dumpNextPacket(DirectTmSinkIF& tmSink, size_t& dumpedLen,
-                                                bool& fileHasSwapped) {
-  if (state == State::IDLE) {
+ReturnValue_t PersistentTmStore::getNextDumpPacket(PusTmReader& reader, bool& fileHasSwapped) {
+  if (state == State::IDLE or dumpParams.pendingPacketDump) {
     return returnvalue::FAILED;
   }
-  PusTmReader reader(&timeReader, fileBuf.data() + dumpParams.currentSize,
-                     fileBuf.size() - dumpParams.currentSize);
+  reader.setReadOnlyData(fileBuf.data() + dumpParams.currentSize,
+                         fileBuf.size() - dumpParams.currentSize);
   // CRC check to fully ensure this is a valid TM
   ReturnValue_t result = reader.parseDataWithCrcCheck();
-  if (result == returnvalue::OK) {
-    result = tmSink.write(fileBuf.data() + dumpParams.currentSize, reader.getFullPacketLen());
-    if (result == DirectTmSinkIF::IS_BUSY) {
-      return result;
-    } else if (result != returnvalue::OK) {
-      // TODO: Event?
-      sif::error << "PersistentTmStore: Writing to TM sink failed" << std::endl;
-      return result;
-    }
-    dumpParams.currentSize += reader.getFullPacketLen();
-    dumpedLen = reader.getFullPacketLen();
-    if (dumpParams.currentSize >= dumpParams.fileSize) {
-      fileHasSwapped = true;
-      return loadNextDumpFile();
-    }
-  } else {
+  if (result != returnvalue::OK) {
     sif::error << "PersistentTmStore: Parsing of PUS TM failed with code " << result << std::endl;
     triggerEvent(persTmStore::POSSIBLE_FILE_CORRUPTION, result, dumpParams.currentFileUnixStamp);
     // Delete the file and load next. Could use better algorithm to partially
     // restore the file dump, but for now do not trust the file.
-    dumpedLen = 0;
     std::error_code e;
     std::filesystem::remove(dumpParams.dirEntry.path().c_str(), e);
     fileHasSwapped = true;
     return loadNextDumpFile();
   }
+  fileHasSwapped = false;
+  dumpParams.pendingPacketDump = true;
+  return returnvalue::OK;
+}
+
+ReturnValue_t PersistentTmStore::confirmDump(const PusTmReader& reader, bool& fileHasSwapped) {
+  dumpParams.pendingPacketDump = false;
+  dumpParams.currentSize += reader.getFullPacketLen();
+  if (dumpParams.currentSize >= dumpParams.fileSize) {
+    fileHasSwapped = true;
+    return loadNextDumpFile();
+  }
+  fileHasSwapped = false;
   return returnvalue::OK;
 }
 
@@ -293,7 +290,7 @@ ReturnValue_t PersistentTmStore::pathToTime(const std::filesystem::path& path, s
   auto pathStr = path.string();
   size_t splitChar = pathStr.find('_');
   auto timeOnlyStr = pathStr.substr(splitChar + 1);
-  if (nullptr == strptime(timeOnlyStr.c_str(), FILE_DATE_FORMAT, &time)) {
+  if (nullptr == strptime(timeOnlyStr.c_str(), config::FILE_DATE_FORMAT, &time)) {
     return returnvalue::FAILED;
   }
   return returnvalue::OK;
@@ -310,7 +307,7 @@ ReturnValue_t PersistentTmStore::createMostRecentFile(std::optional<uint8_t> suf
   time_t epoch = currentTv.tv_sec;
   struct tm* time = gmtime(&epoch);
   size_t writtenBytes = strftime(reinterpret_cast<char*>(fileBuf.data() + currentIdx),
-                                 fileBuf.size(), FILE_DATE_FORMAT, time);
+                                 fileBuf.size(), config::FILE_DATE_FORMAT, time);
   if (writtenBytes == 0) {
     sif::error << "PersistentTmStore::createMostRecentFile: Could not create file timestamp"
                << std::endl;

mission/tmtc/PersistentTmStore.h

@@ -4,12 +4,10 @@
 #include <fsfw/ipc/CommandMessageIF.h>
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/storagemanager/StorageManagerIF.h>
-#include <fsfw/timemanager/CdsShortTimeStamper.h>
 #include <fsfw/tmstorage/TmStoreFrontendSimpleIF.h>
 #include <fsfw/tmtcpacket/pus/tm/PusTmReader.h>
 #include <fsfw/tmtcservices/AcceptsTelemetryIF.h>
 #include <mission/memory/SdCardMountedIF.h>
-#include <mission/tmtc/DirectTmSinkIF.h>
 
 #include <filesystem>
 
@@ -57,13 +55,25 @@ class PersistentTmStore : public TmStoreFrontendSimpleIF, public SystemObject {
   ReturnValue_t startDumpFromUpTo(uint32_t fromUnixSeconds, uint32_t upToUnixSeconds);
   /**
    *
-   * @param tmSink
-   * @param dumpedLen
-   * @param fileHasSwapped
-   * @return DUMP_DONE if dump is finished, returnvalue::OK if dump of next packet was a success,
-   *   and DirectTmSinkIF::IS_BUSY is TM sink is busy.
+   * @param tmReader: Next packet will be loaded into the PUS TM reader. A CRC check will be
+   *    performed on the packet. If that check fails, the file is considered corrupted and will
+   *    be deleted for now.
+   * @param fileHasSwapped: If the CRC check fails, the file will be deleted and a new one has to
+   *    be loaded. The dump can reach completion during that process. If a file is swapped, this
+   *    boolean is set to true
+   * @return DUMP_DONE if dump is finished, returnvalue::OK if the next packet was loaded into the
+   *    TM reader, and the returnvalue of the file swap operation if the CRC check failed and
+   *    a new file was loaded.
    */
-  ReturnValue_t dumpNextPacket(DirectTmSinkIF& tmSink, size_t& dumpedLen, bool& fileHasSwapped);
+  ReturnValue_t getNextDumpPacket(PusTmReader& tmReader, bool& fileHasSwapped);
+  /**
+   * Confirm the dump to advance the dump state machine.
+   * @param tmReader
+   * @param fileHasSwapped: If the confirmed dumps completes the current file, a new file will
+   *    be loaded and this parameter will be set to true.
+   * @return If a file is swapped, the retrunvalue of the file swap operation.
+   */
+  ReturnValue_t confirmDump(const PusTmReader& tmReader, bool& fileHasSwapped);
 
   void getStartAndEndTimeCurrentOrLastDump(uint32_t& startTime, uint32_t& endTime) const;
   ReturnValue_t storePacket(PusTmReader& reader);
@@ -75,16 +85,12 @@ class PersistentTmStore : public TmStoreFrontendSimpleIF, public SystemObject {
  private:
   static constexpr uint8_t MAX_FILES_IN_ONE_SECOND = 10;
   static constexpr size_t MAX_FILESIZE = 8192;
-  // ISO8601 timestamp.
-  static constexpr char FILE_DATE_FORMAT[] = "%FT%H%M%SZ";
 
   //! [EXPORT] : [SKIP]
   static constexpr ReturnValue_t INVALID_FILE_DETECTED_AND_DELETED = returnvalue::makeCode(2, 1);
 
   MessageQueueIF* tcQueue;
   State state = State::IDLE;
-  // PacketFilter filter;
-  CdsShortTimeStamper timeReader;
   bool baseDirUninitialized = true;
   const char* baseDir;
   std::string baseName;
@@ -96,6 +102,7 @@ class PersistentTmStore : public TmStoreFrontendSimpleIF, public SystemObject {
   timeval activeFileTv{};
 
   struct ActiveDumpParams {
+    bool pendingPacketDump = false;
     uint32_t fromUnixTime = 0;
     uint32_t untilUnixTime = 0;
     uint32_t currentFileUnixStamp = 0;

mission/tmtc/TmStoreTaskBase.cpp

@@ -1,131 +0,0 @@
-#include "TmStoreTaskBase.h"
-
-#include <fsfw/ipc/CommandMessageIF.h>
-#include <fsfw/tasks/TaskFactory.h>
-#include <fsfw/timemanager/Stopwatch.h>
-#include <fsfw/tmstorage/TmStoreMessage.h>
-
-#include "mission/persistentTmStoreDefs.h"
-
-TmStoreTaskBase::TmStoreTaskBase(object_id_t objectId, StorageManagerIF& ipcStore,
-                                 VirtualChannel& channel, SdCardMountedIF& sdcMan)
-    : SystemObject(objectId), ipcStore(ipcStore), channel(channel), sdcMan(sdcMan) {}
-
-bool TmStoreTaskBase::handleOneStore(PersistentTmStoreWithTmQueue& store,
-                                     DumpContext& dumpContext) {
-  ReturnValue_t result;
-  bool tmToStoreReceived = false;
-  bool tcRequestReceived = false;
-  bool dumpPerformed = false;
-  fileHasSwapped = false;
-  dumpContext.packetWasDumped = false;
-  dumpContext.vcBusyDuringDump = false;
-
-  // Store TM persistently
-  result = store.handleNextTm();
-  if (result == returnvalue::OK) {
-    tmToStoreReceived = true;
-  }
-  // Dump TMs when applicable
-  if (store.getState() == PersistentTmStore::State::DUMPING) {
-    if (handleOneDump(store, dumpContext, dumpPerformed) != returnvalue::OK) {
-      return result;
-    }
-  } else {
-    Command_t execCmd;
-    // Handle TC requests, for example deletion or retrieval requests.
-    result = store.handleCommandQueue(ipcStore, execCmd);
-    if (result == returnvalue::OK) {
-      if (execCmd == TmStoreMessage::DOWNLINK_STORE_CONTENT_TIME) {
-        cancelDumpCd.resetTimer();
-        tmSinkBusyCd.resetTimer();
-        dumpContext.reset();
-      }
-      tcRequestReceived = true;
-    }
-  }
-  if (tcRequestReceived or tmToStoreReceived or dumpPerformed) {
-    return true;
-  }
-  return false;
-}
-
-bool TmStoreTaskBase::cyclicStoreCheck() {
-  if (not storesInitialized) {
-    storesInitialized = initStoresIfPossible();
-    if (not storesInitialized) {
-      TaskFactory::delayTask(400);
-      return false;
-    }
-  } else if (sdCardCheckCd.hasTimedOut()) {
-    if (not sdcMan.isSdCardUsable(std::nullopt)) {
-      // Might be due to imminent shutdown or SD card switch.
-      storesInitialized = false;
-      TaskFactory::delayTask(100);
-      return false;
-    }
-    sdCardCheckCd.resetTimer();
-  }
-  return true;
-}
-
-void TmStoreTaskBase::cancelDump(DumpContext& ctx, PersistentTmStore& store, bool isTxOn) {
-  triggerEvent(ctx.eventIfCancelled, ctx.numberOfDumpedPackets, ctx.dumpedBytes);
-  ctx.reset();
-  store.cancelDump();
-  if (isTxOn) {
-    channel.cancelTransfer();
-  }
-}
-
-ReturnValue_t TmStoreTaskBase::handleOneDump(PersistentTmStoreWithTmQueue& store,
-                                             DumpContext& dumpContext, bool& dumpPerformed) {
-  ReturnValue_t result = returnvalue::OK;
-  // The PTME might have been reset an transmitter state change, so there is no point in continuing
-  // the dump.
-  if (not channel.isTxOn()) {
-    cancelDump(dumpContext, store, false);
-    return returnvalue::FAILED;
-  }
-  size_t dumpedLen = 0;
-  if (not channel.isBusy()) {
-    // Dump the next packet into the PTME.
-    dumpContext.ptmeBusyCounter = 0;
-    tmSinkBusyCd.resetTimer();
-    result = store.dumpNextPacket(channel, dumpedLen, fileHasSwapped);
-    if (result == DirectTmSinkIF::IS_BUSY) {
-      sif::warning << "Unexpected PAPB busy" << std::endl;
-    }
-    if ((result == PersistentTmStore::DUMP_DONE or result == returnvalue::OK)) {
-      dumpPerformed = true;
-      if (dumpedLen > 0) {
-        dumpContext.dumpedBytes += dumpedLen;
-        dumpContext.numberOfDumpedPackets += 1;
-        dumpContext.packetWasDumped = true;
-      }
-    }
-    if (result == PersistentTmStore::DUMP_DONE) {
-      uint32_t startTime;
-      uint32_t endTime;
-      store.getStartAndEndTimeCurrentOrLastDump(startTime, endTime);
-      triggerEvent(dumpContext.eventIfDone, dumpContext.numberOfDumpedPackets,
-                   dumpContext.dumpedBytes);
-      dumpContext.reset();
-    }
-  } else {
-    // The PTME might be at full load, so it might sense to delay for a bit to let it do
-    // its work until some more bandwidth is available. Set a flag here so the upper layer can
-    // do ths.
-    dumpContext.vcBusyDuringDump = true;
-    dumpContext.ptmeBusyCounter++;
-    if (dumpContext.ptmeBusyCounter == 100) {
-      // If this happens, something is probably wrong.
-      sif::warning << "PTME busy for longer period. Cancelling dump" << std::endl;
-      cancelDump(dumpContext, store, channel.isTxOn());
-    }
-  }
-  if (cancelDumpCd.hasTimedOut() or tmSinkBusyCd.hasTimedOut()) {
-    cancelDump(dumpContext, store, channel.isTxOn());
-  }
-  return result;
-}