Merge remote-tracking branch 'origin/develop' into mueller/pl-ss

bsp_q7s/core/CoreController.cpp

@@ -56,6 +56,7 @@ CoreController::CoreController(object_id_t objectId)
   } catch (const std::filesystem::filesystem_error &e) {
     sif::error << "CoreController::CoreController: Failed with exception " << e.what() << std::endl;
   }
+  sdCardCheckCd.timeOut();
   eventQueue = QueueFactory::instance()->createMessageQueue(5, EventMessage::MAX_MESSAGE_SIZE);
 }
 
@@ -77,6 +78,10 @@ void CoreController::performControlOperation() {
   performWatchdogControlOperation();
   sdStateMachine();
   performMountedSdCardOperations();
+  if (sdCardCheckCd.hasTimedOut()) {
+    performSdCardCheck();
+    sdCardCheckCd.resetTimer();
+  }
   readHkData();
   opDivider5.checkAndIncrement();
   opDivider10.checkAndIncrement();
@@ -134,6 +139,9 @@ ReturnValue_t CoreController::initialize() {
 
 ReturnValue_t CoreController::initializeAfterTaskCreation() {
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  sdInfo.pref = sdcMan->getPreferredSdCard();
+  sdcMan->setActiveSdCard(sdInfo.pref);
+  currMntPrefix = sdcMan->getCurrentMountPrefix();
   if (BLOCKING_SD_INIT) {
     ReturnValue_t result = initSdCardBlocking();
     if (result != HasReturnvaluesIF::RETURN_OK and result != SdCardManager::ALREADY_MOUNTED) {
@@ -165,7 +173,7 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
       if (size < 1) {
         return HasActionsIF::INVALID_PARAMETERS;
       }
-      std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+      std::string path = sdcMan->getCurrentMountPrefix() + REBOOT_FILE;
       // Disable the reboot file mechanism
       parseRebootFile(path, rebootFile);
       if (data[0] == 0) {
@@ -205,7 +213,7 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
       if (size < 1) {
         return HasActionsIF::INVALID_PARAMETERS;
       }
-      std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+      std::string path = sdcMan->getCurrentMountPrefix() + REBOOT_FILE;
       // Disable the reboot file mechanism
       parseRebootFile(path, rebootFile);
       rebootFile.maxCount = data[0];
@@ -242,13 +250,12 @@ ReturnValue_t CoreController::initSdCardBlocking() {
   return HasReturnvaluesIF::RETURN_OK;
 #else
 
-  result = sdcMan->getSdCardActiveStatus(sdInfo.currentState);
+  result = sdcMan->getSdCardsStatus(sdInfo.currentState);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Getting SD card activity status failed" << std::endl;
   }
 
 #if Q7S_SD_CARD_CONFIG == Q7S_SD_COLD_REDUNDANT
-  determinePreferredSdCard();
   updateSdInfoOther();
   sif::info << "Cold redundant SD card configuration, preferred SD card: "
             << static_cast<int>(sdInfo.pref) << std::endl;
@@ -329,8 +336,8 @@ ReturnValue_t CoreController::sdStateMachine() {
 
   if (sdInfo.state == SdStates::SET_STATE_SELF) {
     if (not sdInfo.commandExecuted) {
-      result = sdcMan->getSdCardActiveStatus(sdInfo.currentState);
-      determinePreferredSdCard();
+      result = sdcMan->getSdCardsStatus(sdInfo.currentState);
+      sdInfo.pref = sdcMan->getPreferredSdCard();
       updateSdInfoOther();
       if (sdInfo.pref != sd::SdCard::SLOT_0 and sdInfo.pref != sd::SdCard::SLOT_1) {
         sif::warning << "Preferred SD card invalid. Setting to card 0.." << std::endl;
@@ -473,7 +480,7 @@ ReturnValue_t CoreController::sdStateMachine() {
     sdInfo.state = SdStates::IDLE;
     sdInfo.cycleCount = 0;
     sdcMan->setBlocking(false);
-    sdcMan->getSdCardActiveStatus(sdInfo.currentState);
+    sdcMan->getSdCardsStatus(sdInfo.currentState);
     if (not sdInfo.initFinished) {
       updateSdInfoOther();
       sdInfo.initFinished = true;
@@ -951,25 +958,6 @@ ReturnValue_t CoreController::gracefulShutdownTasks(xsc::Chip chip, xsc::Copy co
 
 CoreController::~CoreController() {}
 
-void CoreController::determinePreferredSdCard() {
-  if (sdInfo.pref == sd::SdCard::NONE) {
-    ReturnValue_t result = sdcMan->getPreferredSdCard(sdInfo.pref);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      if (result == scratch::KEY_NOT_FOUND) {
-        sif::warning << "CoreController::sdCardInit: "
-                        "Preferred SD card not set. Setting to 0"
-                     << std::endl;
-        sdcMan->setPreferredSdCard(sd::SdCard::SLOT_0);
-        sdInfo.pref = sd::SdCard::SLOT_0;
-      } else {
-        sif::warning << "CoreController::sdCardInit: Could not get preferred SD card"
-                        "information from the scratch buffer"
-                     << std::endl;
-      }
-    }
-  }
-}
-
 void CoreController::updateSdInfoOther() {
   if (sdInfo.pref == sd::SdCard::SLOT_0) {
     sdInfo.prefChar = "0";
@@ -1253,24 +1241,73 @@ void CoreController::performWatchdogControlOperation() {
 }
 
 void CoreController::performMountedSdCardOperations() {
-  currMntPrefix = sdcMan->getCurrentMountPrefix();
-  if (doPerformMountedSdCardOps) {
-    bool sdCardMounted = false;
-    sdCardMounted = sdcMan->isSdCardMounted(sdInfo.pref);
-    if (sdCardMounted) {
-      std::string path = currMntPrefix + "/" + CONF_FOLDER;
-      if (not std::filesystem::exists(path)) {
-        std::filesystem::create_directory(path);
+  auto mountedSdCardOp = [&](bool &mntSwitch, sd::SdCard sdCard, std::string mntPoint) {
+    if (mntSwitch) {
+      bool sdCardMounted = sdcMan->isSdCardMounted(sdCard);
+      if (sdCardMounted and not performOneShotSdCardOpsSwitch) {
+        std::ostringstream path;
+        path << mntPoint << "/" << CONF_FOLDER;
+        if (not std::filesystem::exists(path.str())) {
+          std::filesystem::create_directory(path.str());
+        }
+        initVersionFile();
+        initClockFromTimeFile();
+        performRebootFileHandling(false);
+        performOneShotSdCardOpsSwitch = true;
       }
-      initVersionFile();
-      initClockFromTimeFile();
-      performRebootFileHandling(false);
-      doPerformMountedSdCardOps = false;
+      mntSwitch = false;
     }
+  };
+  if (sdInfo.pref == sd::SdCard::SLOT_1) {
+    mountedSdCardOp(sdInfo.mountSwitch.second, sd::SdCard::SLOT_1, SdCardManager::SD_1_MOUNT_POINT);
+    mountedSdCardOp(sdInfo.mountSwitch.first, sd::SdCard::SLOT_0, SdCardManager::SD_0_MOUNT_POINT);
+  } else {
+    mountedSdCardOp(sdInfo.mountSwitch.first, sd::SdCard::SLOT_0, SdCardManager::SD_0_MOUNT_POINT);
+    mountedSdCardOp(sdInfo.mountSwitch.second, sd::SdCard::SLOT_1, SdCardManager::SD_1_MOUNT_POINT);
   }
   timeFileHandler();
 }
 
+ReturnValue_t CoreController::performSdCardCheck() {
+  bool mountedReadOnly = false;
+  SdCardManager::SdStatePair active;
+  sdcMan->getSdCardsStatus(active);
+  auto sdCardCheck = [&](sd::SdCard sdCard) {
+    ReturnValue_t result = sdcMan->isSdCardMountedReadOnly(sdCard, mountedReadOnly);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      sif::error << "CoreController::performSdCardCheck: Could not check "
+                    "read-only mount state"
+                 << std::endl;
+      mountedReadOnly = true;
+    }
+    if (mountedReadOnly) {
+      int linuxErrno = 0;
+      result = sdcMan->performFsck(sdCard, true, linuxErrno);
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        sif::error << "CoreController::performSdCardCheck: fsck command on SD Card "
+                   << static_cast<uint8_t>(sdCard) << " failed with code " << linuxErrno << " | "
+                   << strerror(linuxErrno);
+      }
+      result = sdcMan->remountReadWrite(sdCard);
+      if (result == HasReturnvaluesIF::RETURN_OK) {
+        sif::warning << "CoreController::performSdCardCheck: Remounted SD Card "
+                     << static_cast<uint8_t>(sdCard) << " read-write";
+      } else {
+        sif::error << "CoreController::performSdCardCheck: Remounting SD Card "
+                   << static_cast<uint8_t>(sdCard) << " read-write failed";
+      }
+    }
+  };
+  if (active.first == sd::SdState::MOUNTED) {
+    sdCardCheck(sd::SdCard::SLOT_0);
+  }
+  if (active.second == sd::SdState::MOUNTED) {
+    sdCardCheck(sd::SdCard::SLOT_1);
+  }
+
+  return RETURN_OK;
+}
+
 void CoreController::performRebootFileHandling(bool recreateFile) {
   using namespace std;
   std::string path = currMntPrefix + REBOOT_FILE;
@@ -1696,7 +1733,7 @@ void CoreController::rewriteRebootFile(RebootFile file) {
 }
 
 void CoreController::setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy) {
-  std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+  std::string path = currMntPrefix + REBOOT_FILE;
   // Disable the reboot file mechanism
   parseRebootFile(path, rebootFile);
   if (tgtChip == xsc::CHIP_0) {

bsp_q7s/core/CoreController.h

@@ -162,11 +162,12 @@ class CoreController : public ExtendedControllerBase {
 
   struct SdInfo {
     sd::SdCard pref = sd::SdCard::NONE;
-    sd::SdState prefState = sd::SdState::OFF;
     sd::SdCard other = sd::SdCard::NONE;
+    sd::SdState prefState = sd::SdState::OFF;
     sd::SdState otherState = sd::SdState::OFF;
     std::string prefChar = "0";
     std::string otherChar = "1";
+    std::pair<bool, bool> mountSwitch = {true, true};
     SdStates state = SdStates::START;
     // Used to track whether a command was executed
     bool commandExecuted = true;
@@ -182,7 +183,7 @@ class CoreController : public ExtendedControllerBase {
   } sdInfo;
   RebootFile rebootFile = {};
   std::string currMntPrefix;
-  bool doPerformMountedSdCardOps = true;
+  bool performOneShotSdCardOpsSwitch = true;
 
   /**
    * Index 0: Chip 0 Copy 0
@@ -198,12 +199,14 @@ class CoreController : public ExtendedControllerBase {
 
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override;
+  Countdown sdCardCheckCd = Countdown(120000);
   LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, uint32_t* msToReachTheMode);
   void performMountedSdCardOperations();
   ReturnValue_t initVersionFile();
 
   ReturnValue_t initClockFromTimeFile();
+  ReturnValue_t performSdCardCheck();
   ReturnValue_t timeFileHandler();
   ReturnValue_t initBootCopy();
   ReturnValue_t initWatchdogFifo();
@@ -217,7 +220,6 @@ class CoreController : public ExtendedControllerBase {
   ReturnValue_t sdColdRedundantBlockingInit();
 
   void currentStateSetter(sd::SdCard sdCard, sd::SdState newState);
-  void determinePreferredSdCard();
   void executeNextExternalSdCommand();
   void checkExternalSdCommandStatus();
   void performRebootFileHandling(bool recreateFile);

bsp_q7s/core/InitMission.cpp

@@ -429,13 +429,22 @@ void initmission::createPusTasks(TaskFactory& factory,
 
   PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
       "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
+
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_3", objects::PUS_SERVICE_3_HOUSEKEEPING);
+  }
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS_8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
   }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_11_TC_SCHEDULER);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "Object add component failed" << std::endl;
+    initmission::printAddObjectError("PUS_11", objects::PUS_SERVICE_11_TC_SCHEDULER);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_20", objects::PUS_SERVICE_20_PARAMETERS);
   }
   result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
   if (result != HasReturnvaluesIF::RETURN_OK) {
@@ -445,10 +454,6 @@ void initmission::createPusTasks(TaskFactory& factory,
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("PUS_201", objects::PUS_SERVICE_201_HEALTH);
   }
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    initmission::printAddObjectError("PUS_20", objects::PUS_SERVICE_20_PARAMETERS);
-  }
   taskVec.push_back(pusMedPrio);
 
   PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(

bsp_q7s/core/ObjectFactory.cpp

@@ -93,8 +93,7 @@
 #include "mission/tmtc/VirtualChannel.h"
 #include "mission/utility/TmFunnel.h"
 
-ResetArgs resetArgsGnss0;
-ResetArgs resetArgsGnss1;
+ResetArgs RESET_ARGS_GNSS;
 
 void Factory::setStaticFrameworkObjectIds() {
   PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
@@ -462,15 +461,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
 #if OBSW_DEBUG_GPS == 1
   debugGps = true;
 #endif
-  resetArgsGnss1.gnss1 = true;
-  resetArgsGnss1.gpioComIF = gpioComIF;
-  resetArgsGnss1.waitPeriodMs = 100;
-  resetArgsGnss0.gnss1 = false;
-  resetArgsGnss0.gpioComIF = gpioComIF;
-  resetArgsGnss0.waitPeriodMs = 100;
-  auto gpsHandler0 =
+  RESET_ARGS_GNSS.gpioComIF = gpioComIF;
+  RESET_ARGS_GNSS.waitPeriodMs = 100;
+  auto gpsCtrl =
       new GPSHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT, debugGps);
-  gpsHandler0->setResetPinTriggerFunction(gps::triggerGpioResetPin, &resetArgsGnss0);
+  gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);
 
   AcsBoardHelper acsBoardHelper = AcsBoardHelper(
       objects::MGM_0_LIS3_HANDLER, objects::MGM_1_RM3100_HANDLER, objects::MGM_2_LIS3_HANDLER,