Merge branch 'develop' into meier/startracker

.gitignore

@@ -9,7 +9,7 @@
 !misc/eclipse/**/.project
 
 #vscode
-.vscode
+/.vscode
 
 # Python
 __pycache__

README.md

@@ -442,12 +442,24 @@ Beagle Bone Black for download here
 Download it and unzip it somewhere in the Xilinx installation folder.
 You can use the following command if `wget` can be used or for CI/CD:
 
-```
+```sh
-wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/agnJGYeRf6fw2ci/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz
+wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/SyXpdBBQX32xPgE/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz
 ```
 
 Then, create a new environmental variables `Q7S_SYSROOT` and set it to the local system root path.
 
+### Updating system root for CI
+
+If the system root is updated, it needs to be manually updated on the buggy file server.
+If access on `buggy.irs.uni-stuttgart.de` is possible with `ssh` and the rootfs in the cloud
+[was updated](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/rootfs&fileid=831849)
+as well, you can update the rootfs like this:
+
+```sh
+cd /var/www/eive/tools
+wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/SyXpdBBQX32xPgE/download/cortexa9hf-neon-xiphos-linux-gnueabi.tar.gz
+```
+
 ## Setting up UNIX environment for real-time functionalities
 
 Please note that on most UNIX environments (e.g. Ubuntu), the real time functionalities 

bsp_q7s/boardtest/Q7STestTask.cpp

@@ -170,15 +170,15 @@ void Q7STestTask::testProtHandler() {
   bool opPerformed = false;
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
   // If any chips are unlocked, lock them here
-  result = coreController->setBootCopyProtection(
+  result = coreController->setBootCopyProtection(xsc::Chip::ALL_CHIP, xsc::Copy::ALL_COPY, true,
-      CoreController::Chip::ALL_CHIP, CoreController::Copy::ALL_COPY, true, opPerformed, true);
+                                                 opPerformed, true);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }
 
   // unlock own copy
-  result = coreController->setBootCopyProtection(
+  result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, false,
-      CoreController::Chip::SELF_CHIP, CoreController::Copy::SELF_COPY, false, opPerformed, true);
+                                                 opPerformed, true);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }
@@ -191,8 +191,8 @@ void Q7STestTask::testProtHandler() {
   }
 
   // lock own copy
-  result = coreController->setBootCopyProtection(
+  result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, true,
-      CoreController::Chip::SELF_CHIP, CoreController::Copy::SELF_COPY, true, opPerformed, true);
+                                                 opPerformed, true);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }
@@ -205,8 +205,8 @@ void Q7STestTask::testProtHandler() {
   }
 
   // unlock specific copy
-  result = coreController->setBootCopyProtection(
+  result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, false,
-      CoreController::Chip::CHIP_1, CoreController::Copy::COPY_1, false, opPerformed, true);
+                                                 opPerformed, true);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }
@@ -219,8 +219,8 @@ void Q7STestTask::testProtHandler() {
   }
 
   // lock specific copy
-  result = coreController->setBootCopyProtection(
+  result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, true,
-      CoreController::Chip::CHIP_1, CoreController::Copy::COPY_1, true, opPerformed, true);
+                                                 opPerformed, true);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
   }

bsp_q7s/core/CoreController.cpp

@@ -1,5 +1,7 @@
 #include "CoreController.h"
 
+#include <fsfw/events/EventManager.h>
+
 #include "OBSWConfig.h"
 #include "OBSWVersion.h"
 #include "fsfw/FSFWVersion.h"
@@ -20,8 +22,8 @@
 #include "bsp_q7s/memory/SdCardManager.h"
 #include "bsp_q7s/memory/scratchApi.h"
 
-CoreController::Chip CoreController::CURRENT_CHIP = Chip::NO_CHIP;
+xsc::Chip CoreController::CURRENT_CHIP = xsc::Chip::NO_CHIP;
-CoreController::Copy CoreController::CURRENT_COPY = Copy::NO_COPY;
+xsc::Copy CoreController::CURRENT_COPY = xsc::Copy::NO_COPY;
 
 CoreController::CoreController(object_id_t objectId)
     : ExtendedControllerBase(objectId, objects::NO_OBJECT, 5), opDivider(5) {
@@ -57,6 +59,7 @@ ReturnValue_t CoreController::handleCommandMessage(CommandMessage *message) {
 void CoreController::performControlOperation() {
   performWatchdogControlOperation();
   sdStateMachine();
+  performMountedSdCardOperations();
 }
 
 ReturnValue_t CoreController::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
@@ -77,6 +80,8 @@ ReturnValue_t CoreController::initialize() {
   }
 
   sdStateMachine();
+
+  triggerEvent(REBOOT_SW, CURRENT_CHIP, CURRENT_COPY);
   return ExtendedControllerBase::initialize();
 }
 
@@ -89,7 +94,7 @@ ReturnValue_t CoreController::initializeAfterTaskCreation() {
     }
   }
   sdStateMachine();
-  result = initVersionFile();
+  performMountedSdCardOperations();
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::warning << "CoreController::initialize: Version initialization failed" << std::endl;
   }
@@ -102,6 +107,72 @@ ReturnValue_t CoreController::initializeAfterTaskCreation() {
   return result;
 }
 
+ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                                            const uint8_t *data, size_t size) {
+  switch (actionId) {
+    case (LIST_DIRECTORY_INTO_FILE): {
+      return actionListDirectoryIntoFile(actionId, commandedBy, data, size);
+    }
+    case (SWITCH_REBOOT_FILE_HANDLING): {
+      if (size < 1) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+      // Disable the reboot file mechanism
+      parseRebootFile(path, rebootFile);
+      if (data[0] == 0) {
+        rebootFile.enabled = false;
+        rewriteRebootFile(rebootFile);
+      } else if (data[0] == 1) {
+        rebootFile.enabled = true;
+        rewriteRebootFile(rebootFile);
+      } else {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
+    case (RESET_REBOOT_COUNTERS): {
+      if (size == 0) {
+        resetRebootCount(xsc::ALL_CHIP, xsc::ALL_COPY);
+      } else if (size == 2) {
+        if (data[0] > 1 or data[1] > 1) {
+          return HasActionsIF::INVALID_PARAMETERS;
+        }
+        resetRebootCount(static_cast<xsc::Chip>(data[0]), static_cast<xsc::Copy>(data[1]));
+      }
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
+    case (SWITCH_IMG_LOCK): {
+      if (size != 3) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      if (data[1] > 1 or data[2] > 1) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      setRebootMechanismLock(data[0], static_cast<xsc::Chip>(data[1]),
+                             static_cast<xsc::Copy>(data[2]));
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
+    case (SET_MAX_REBOOT_CNT): {
+      if (size < 1) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+      // Disable the reboot file mechanism
+      parseRebootFile(path, rebootFile);
+      rebootFile.maxCount = data[0];
+      rewriteRebootFile(rebootFile);
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
+    case (REBOOT_OBC): {
+      return actionPerformReboot(data, size);
+    }
+    default: {
+      return HasActionsIF::INVALID_ACTION_ID;
+    }
+  }
+}
+
 ReturnValue_t CoreController::checkModeCommand(Mode_t mode, Submode_t submode,
                                                uint32_t *msToReachTheMode) {
   return HasReturnvaluesIF::RETURN_OK;
@@ -500,21 +571,6 @@ ReturnValue_t CoreController::sdCardSetup(sd::SdCard sdCard, sd::SdState targetS
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                            const uint8_t *data, size_t size) {
-  switch (actionId) {
-    case (LIST_DIRECTORY_INTO_FILE): {
-      return actionListDirectoryIntoFile(actionId, commandedBy, data, size);
-    }
-    case (REBOOT_OBC): {
-      return actionPerformReboot(data, size);
-    }
-    default: {
-      return HasActionsIF::INVALID_ACTION_ID;
-    }
-  }
-}
-
 ReturnValue_t CoreController::sdColdRedundantBlockingInit() {
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 
@@ -689,7 +745,7 @@ ReturnValue_t CoreController::actionListDirectoryIntoFile(ActionId_t actionId,
 
 ReturnValue_t CoreController::initBootCopy() {
   if (not std::filesystem::exists(CURR_COPY_FILE)) {
-    // Thils file is created by the systemd service eive-early-config so this should
+    // This file is created by the systemd service eive-early-config so this should
     // not happen normally
     std::string cmd = "xsc_boot_copy > " + std::string(CURR_COPY_FILE);
     int result = std::system(cmd.c_str());
@@ -697,22 +753,18 @@ ReturnValue_t CoreController::initBootCopy() {
       utility::handleSystemError(result, "CoreController::initBootCopy");
     }
   }
-  std::ifstream file(CURR_COPY_FILE);
+
-  std::string line;
+  getCurrentBootCopy(CURRENT_CHIP, CURRENT_COPY);
-  std::getline(file, line);
-  std::istringstream iss(line);
-  int value = 0;
-  iss >> value;
-  CURRENT_CHIP = static_cast<Chip>(value);
-  iss >> value;
-  CURRENT_COPY = static_cast<Copy>(value);
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-void CoreController::getCurrentBootCopy(Chip &chip, Copy &copy) {
+void CoreController::getCurrentBootCopy(xsc::Chip &chip, xsc::Copy &copy) {
+  xsc_libnor_chip_t xscChip;
+  xsc_libnor_copy_t xscCopy;
+  xsc_boot_get_chip_copy(&xscChip, &xscCopy);
   // Not really thread-safe but it does not need to be
-  chip = CURRENT_CHIP;
+  chip = static_cast<xsc::Chip>(xscChip);
-  copy = CURRENT_COPY;
+  copy = static_cast<xsc::Copy>(xscCopy);
 }
 
 ReturnValue_t CoreController::initWatchdogFifo() {
@@ -759,8 +811,8 @@ ReturnValue_t CoreController::actionPerformReboot(const uint8_t *data, size_t si
     SdCardManager::instance()->switchOffSdCard(sd::SdCard::SLOT_0);
     SdCardManager::instance()->switchOffSdCard(sd::SdCard::SLOT_1);
     // If any boot copies are unprotected
-    ReturnValue_t retval =
+    ReturnValue_t retval = setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, true,
-        setBootCopyProtection(Chip::SELF_CHIP, Copy::SELF_COPY, true, protOpPerformed, false);
+                                                 protOpPerformed, false);
     if (retval == HasReturnvaluesIF::RETURN_OK and protOpPerformed) {
       sif::info << "Running slot was writeprotected before reboot" << std::endl;
     }
@@ -771,7 +823,7 @@ ReturnValue_t CoreController::actionPerformReboot(const uint8_t *data, size_t si
     }
     return HasActionsIF::EXECUTION_FINISHED;
   }
-  if (size < 3) {
+  if (size < 3 or (data[1] > 1 or data[2] > 1)) {
     return HasActionsIF::INVALID_PARAMETERS;
   }
 #if OBSW_VERBOSE_LEVEL >= 1
@@ -782,21 +834,53 @@ ReturnValue_t CoreController::actionPerformReboot(const uint8_t *data, size_t si
   // Check that the target chip and copy is writeprotected first
   generateChipStateFile();
   // If any boot copies are unprotected, protect them here
-  ReturnValue_t retval = setBootCopyProtection(
+  auto tgtChip = static_cast<xsc::Chip>(data[1]);
-      static_cast<Chip>(data[1]), static_cast<Copy>(data[2]), true, protOpPerformed, false);
+  auto tgtCopy = static_cast<xsc::Copy>(data[2]);
+
+  ReturnValue_t retval =
+      setBootCopyProtection(static_cast<xsc::Chip>(data[1]), static_cast<xsc::Copy>(data[2]), true,
+                            protOpPerformed, false);
   if (retval == HasReturnvaluesIF::RETURN_OK and protOpPerformed) {
     sif::info << "Target slot was writeprotected before reboot" << std::endl;
   }
 
-  // The second byte in data is the target chip, the third byte is the target copy
+  switch (tgtChip) {
-  std::string cmdString =
+    case (xsc::Chip::CHIP_0): {
-      "xsc_boot_copy " + std::to_string(data[1]) + " " + std::to_string(data[2]);
+      switch (tgtCopy) {
-  int result = std::system(cmdString.c_str());
+        case (xsc::Copy::COPY_0): {
-  if (result != 0) {
+          xsc_boot_copy(XSC_LIBNOR_CHIP_0, XSC_LIBNOR_COPY_NOMINAL);
-    utility::handleSystemError(result, "CoreController::executeAction");
+          break;
-    return HasReturnvaluesIF::RETURN_FAILED;
+        }
+        case (xsc::Copy::COPY_1): {
+          xsc_boot_copy(XSC_LIBNOR_CHIP_0, XSC_LIBNOR_COPY_GOLD);
+          break;
+        }
+        default: {
+          break;
+        }
+      }
+      break;
+    }
+    case (xsc::Chip::CHIP_1): {
+      switch (tgtCopy) {
+        case (xsc::Copy::COPY_0): {
+          xsc_boot_copy(XSC_LIBNOR_CHIP_1, XSC_LIBNOR_COPY_NOMINAL);
+          break;
+        }
+        case (xsc::Copy::COPY_1): {
+          xsc_boot_copy(XSC_LIBNOR_CHIP_1, XSC_LIBNOR_COPY_GOLD);
+          break;
+        }
+        default: {
+          break;
+        }
+      }
+      break;
+    }
+    default:
+      break;
   }
-  return HasActionsIF::EXECUTION_FINISHED;
+  return HasReturnvaluesIF::RETURN_FAILED;
 }
 
 CoreController::~CoreController() {}
@@ -850,8 +934,8 @@ ReturnValue_t CoreController::generateChipStateFile() {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t CoreController::setBootCopyProtection(Chip targetChip, Copy targetCopy, bool protect,
+ReturnValue_t CoreController::setBootCopyProtection(xsc::Chip targetChip, xsc::Copy targetCopy,
-                                                    bool &protOperationPerformed,
+                                                    bool protect, bool &protOperationPerformed,
                                                     bool updateProtFile) {
   bool allChips = false;
   bool allCopies = false;
@@ -860,14 +944,14 @@ ReturnValue_t CoreController::setBootCopyProtection(Chip targetChip, Copy target
   protOperationPerformed = false;
 
   switch (targetChip) {
-    case (Chip::ALL_CHIP): {
+    case (xsc::Chip::ALL_CHIP): {
       allChips = true;
       break;
     }
-    case (Chip::NO_CHIP): {
+    case (xsc::Chip::NO_CHIP): {
       return HasReturnvaluesIF::RETURN_OK;
     }
-    case (Chip::SELF_CHIP): {
+    case (xsc::Chip::SELF_CHIP): {
       selfChip = true;
       targetChip = CURRENT_CHIP;
       break;
@@ -877,14 +961,14 @@ ReturnValue_t CoreController::setBootCopyProtection(Chip targetChip, Copy target
     }
   }
   switch (targetCopy) {
-    case (Copy::ALL_COPY): {
+    case (xsc::Copy::ALL_COPY): {
       allCopies = true;
       break;
     }
-    case (Copy::NO_COPY): {
+    case (xsc::Copy::NO_COPY): {
       return HasReturnvaluesIF::RETURN_OK;
     }
-    case (Copy::SELF_COPY): {
+    case (xsc::Copy::SELF_COPY): {
       selfCopy = true;
       targetCopy = CURRENT_COPY;
       break;
@@ -907,10 +991,10 @@ ReturnValue_t CoreController::setBootCopyProtection(Chip targetChip, Copy target
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-int CoreController::handleBootCopyProtAtIndex(Chip targetChip, Copy targetCopy, bool protect,
+int CoreController::handleBootCopyProtAtIndex(xsc::Chip targetChip, xsc::Copy targetCopy,
-                                              bool &protOperationPerformed, bool selfChip,
+                                              bool protect, bool &protOperationPerformed,
-                                              bool selfCopy, bool allChips, bool allCopies,
+                                              bool selfChip, bool selfCopy, bool allChips,
-                                              uint8_t arrIdx) {
+                                              bool allCopies, uint8_t arrIdx) {
   bool currentProt = protArray[arrIdx];
   std::ostringstream oss;
   bool performOp = false;
@@ -923,22 +1007,22 @@ int CoreController::handleBootCopyProtAtIndex(Chip targetChip, Copy targetCopy,
       return 1;
     }
   }
-  Chip currentChip;
+  xsc::Chip currentChip;
-  Copy currentCopy;
+  xsc::Copy currentCopy;
   oss << "writeprotect ";
   if (arrIdx == 0 or arrIdx == 1) {
     oss << "0 ";
-    currentChip = Chip::CHIP_0;
+    currentChip = xsc::Chip::CHIP_0;
   } else {
     oss << "1 ";
-    currentChip = Chip::CHIP_1;
+    currentChip = xsc::Chip::CHIP_1;
   }
   if (arrIdx == 0 or arrIdx == 2) {
     oss << "0 ";
-    currentCopy = Copy::COPY_0;
+    currentCopy = xsc::Copy::COPY_0;
   } else {
     oss << "1 ";
-    currentCopy = Copy::COPY_1;
+    currentCopy = xsc::Copy::COPY_1;
   }
   if (protect) {
     oss << "1";
@@ -1033,29 +1117,29 @@ ReturnValue_t CoreController::handleProtInfoUpdateLine(std::string nextLine) {
   uint8_t wordIdx = 0;
   uint8_t arrayIdx = 0;
   istringstream iss(nextLine);
-  Chip currentChip = Chip::CHIP_0;
+  xsc::Chip currentChip = xsc::Chip::CHIP_0;
-  Copy currentCopy = Copy::COPY_0;
+  xsc::Copy currentCopy = xsc::Copy::COPY_0;
   while (iss >> word) {
     if (wordIdx == 1) {
-      currentChip = static_cast<Chip>(stoi(word));
+      currentChip = static_cast<xsc::Chip>(stoi(word));
     }
     if (wordIdx == 3) {
-      currentCopy = static_cast<Copy>(stoi(word));
+      currentCopy = static_cast<xsc::Copy>(stoi(word));
     }
 
     if (wordIdx == 3) {
-      if (currentChip == Chip::CHIP_0) {
+      if (currentChip == xsc::Chip::CHIP_0) {
-        if (currentCopy == Copy::COPY_0) {
+        if (currentCopy == xsc::Copy::COPY_0) {
           arrayIdx = 0;
-        } else if (currentCopy == Copy::COPY_1) {
+        } else if (currentCopy == xsc::Copy::COPY_1) {
           arrayIdx = 1;
         }
       }
 
-      else if (currentChip == Chip::CHIP_1) {
+      else if (currentChip == xsc::Chip::CHIP_1) {
-        if (currentCopy == Copy::COPY_0) {
+        if (currentCopy == xsc::Copy::COPY_0) {
           arrayIdx = 2;
-        } else if (currentCopy == Copy::COPY_1) {
+        } else if (currentCopy == xsc::Copy::COPY_1) {
           arrayIdx = 3;
         }
       }
@@ -1101,3 +1185,463 @@ void CoreController::performWatchdogControlOperation() {
     }
   }
 }
+
+void CoreController::performMountedSdCardOperations() {
+  if (doPerformMountedSdCardOps) {
+    bool sdCardMounted = false;
+    sdCardMounted = sdcMan->isSdCardMounted(sdInfo.pref);
+    if (sdCardMounted) {
+      std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + "/" + CONF_FOLDER;
+      if (not std::filesystem::exists(path)) {
+        std::filesystem::create_directory(path);
+      }
+      initVersionFile();
+      performRebootFileHandling(false);
+      doPerformMountedSdCardOps = false;
+    }
+  }
+}
+
+void CoreController::performRebootFileHandling(bool recreateFile) {
+  using namespace std;
+  std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+  if (not std::filesystem::exists(path) or recreateFile) {
+#if OBSW_VERBOSE_LEVEL >= 1
+    sif::info << "CoreController::performRebootFileHandling: Recreating reboot file" << std::endl;
+#endif
+    rebootFile.enabled = true;
+    rebootFile.img00Cnt = 0;
+    rebootFile.img01Cnt = 0;
+    rebootFile.img10Cnt = 0;
+    rebootFile.img11Cnt = 0;
+    rebootFile.lastChip = xsc::Chip::CHIP_0;
+    rebootFile.lastCopy = xsc::Copy::COPY_0;
+    rebootFile.img00Lock = false;
+    rebootFile.img01Lock = false;
+    rebootFile.img10Lock = false;
+    rebootFile.img11Lock = false;
+    rebootFile.mechanismNextChip = xsc::Chip::NO_CHIP;
+    rebootFile.mechanismNextCopy = xsc::Copy::NO_COPY;
+    rebootFile.bootFlag = false;
+    rewriteRebootFile(rebootFile);
+  } else {
+    if (not parseRebootFile(path, rebootFile)) {
+      performRebootFileHandling(true);
+    }
+  }
+
+  if (CURRENT_CHIP == xsc::CHIP_0) {
+    if (CURRENT_COPY == xsc::COPY_0) {
+      rebootFile.img00Cnt++;
+    } else {
+      rebootFile.img01Cnt++;
+    }
+  } else {
+    if (CURRENT_COPY == xsc::COPY_0) {
+      rebootFile.img10Cnt++;
+    } else {
+      rebootFile.img11Cnt++;
+    }
+  }
+
+  if (rebootFile.bootFlag) {
+    // Trigger event to inform ground that a reboot was triggered
+    uint32_t p1 = rebootFile.lastChip << 16 | rebootFile.lastCopy;
+    uint32_t p2 = rebootFile.img00Cnt << 24 | rebootFile.img01Cnt << 16 | rebootFile.img10Cnt << 8 |
+                  rebootFile.img11Cnt;
+    triggerEvent(REBOOT_MECHANISM_TRIGGERED, p1, p2);
+    // Clear the boot flag
+    rebootFile.bootFlag = false;
+  }
+
+  if (rebootFile.mechanismNextChip != xsc::NO_CHIP and
+      rebootFile.mechanismNextCopy != xsc::NO_COPY) {
+    if (CURRENT_CHIP != rebootFile.mechanismNextChip or
+        CURRENT_COPY != rebootFile.mechanismNextCopy) {
+      std::string infoString = std::to_string(rebootFile.mechanismNextChip) + " " +
+                               std::to_string(rebootFile.mechanismNextCopy);
+      sif::warning << "CoreController::performRebootFileHandling: Expected to be on image "
+                   << infoString << " but currently on other image. Locking " << infoString
+                   << std::endl;
+      // Firmware or other component might be corrupt and we are on another image then the target
+      // image specified by the mechanism. We can't really trust the target image anymore.
+      // Lock it for now
+      if (rebootFile.mechanismNextChip == xsc::CHIP_0) {
+        if (rebootFile.mechanismNextCopy == xsc::COPY_0) {
+          rebootFile.img00Lock = true;
+        } else {
+          rebootFile.img01Lock = true;
+        }
+      } else {
+        if (rebootFile.mechanismNextCopy == xsc::COPY_0) {
+          rebootFile.img10Lock = true;
+        } else {
+          rebootFile.img11Lock = true;
+        }
+      }
+    }
+  }
+
+  rebootFile.lastChip = CURRENT_CHIP;
+  rebootFile.lastCopy = CURRENT_COPY;
+  // Only reboot if the reboot functionality is enabled.
+  // The handler will still increment the boot counts
+  if (rebootFile.enabled and (*rebootFile.relevantBootCnt >= rebootFile.maxCount)) {
+    // Reboot to other image
+    bool doReboot = false;
+    xsc::Chip tgtChip = xsc::NO_CHIP;
+    xsc::Copy tgtCopy = xsc::NO_COPY;
+    determineAndExecuteReboot(rebootFile, doReboot, tgtChip, tgtCopy);
+    if (doReboot) {
+      rebootFile.bootFlag = true;
+#if OBSW_VERBOSE_LEVEL >= 1
+      sif::info << "Boot counter for image " << CURRENT_CHIP << " " << CURRENT_COPY
+                << " too high. Rebooting to " << tgtChip << " " << tgtCopy << std::endl;
+#endif
+      rebootFile.mechanismNextChip = tgtChip;
+      rebootFile.mechanismNextCopy = tgtCopy;
+      rewriteRebootFile(rebootFile);
+      xsc_boot_copy(static_cast<xsc_libnor_chip_t>(tgtChip),
+                    static_cast<xsc_libnor_copy_t>(tgtCopy));
+    }
+  } else {
+    rebootFile.mechanismNextChip = xsc::NO_CHIP;
+    rebootFile.mechanismNextCopy = xsc::NO_COPY;
+  }
+  rewriteRebootFile(rebootFile);
+}
+
+void CoreController::determineAndExecuteReboot(RebootFile &rf, bool &needsReboot,
+                                               xsc::Chip &tgtChip, xsc::Copy &tgtCopy) {
+  tgtChip = xsc::CHIP_0;
+  tgtCopy = xsc::COPY_0;
+  needsReboot = false;
+  if ((CURRENT_CHIP == xsc::CHIP_0) and (CURRENT_COPY == xsc::COPY_0) and
+      (rf.img00Cnt >= rf.maxCount)) {
+    needsReboot = true;
+    if (rf.img01Cnt < rf.maxCount and not rf.img01Lock) {
+      tgtCopy = xsc::COPY_1;
+      return;
+    }
+    if (rf.img10Cnt < rf.maxCount and not rf.img10Lock) {
+      tgtChip = xsc::CHIP_1;
+      return;
+    }
+    if (rf.img11Cnt < rf.maxCount and not rf.img11Lock) {
+      tgtChip = xsc::CHIP_1;
+      tgtCopy = xsc::COPY_1;
+      return;
+    }
+    // Can't really do much here. Stay on image
+    sif::warning
+        << "All reboot counts too high or all fallback images locked, already on fallback image"
+        << std::endl;
+    needsReboot = false;
+    return;
+  }
+  if ((CURRENT_CHIP == xsc::CHIP_0) and (CURRENT_COPY == xsc::COPY_1) and
+      (rf.img01Cnt >= rf.maxCount)) {
+    needsReboot = true;
+    if (rf.img00Cnt < rf.maxCount and not rf.img00Lock) {
+      // Reboot on fallback image
+      return;
+    }
+    if (rf.img10Cnt < rf.maxCount and not rf.img10Lock) {
+      tgtChip = xsc::CHIP_1;
+      return;
+    }
+    if (rf.img11Cnt < rf.maxCount and not rf.img11Lock) {
+      tgtChip = xsc::CHIP_1;
+      tgtCopy = xsc::COPY_1;
+    }
+    if (rf.img00Lock) {
+      needsReboot = false;
+    }
+    // Reboot to fallback image
+  }
+  if ((CURRENT_CHIP == xsc::CHIP_1) and (CURRENT_COPY == xsc::COPY_0) and
+      (rf.img10Cnt >= rf.maxCount)) {
+    needsReboot = true;
+    if (rf.img11Cnt < rf.maxCount and not rf.img11Lock) {
+      tgtChip = xsc::CHIP_1;
+      tgtCopy = xsc::COPY_1;
+      return;
+    }
+    if (rf.img00Cnt < rf.maxCount and not rf.img00Lock) {
+      return;
+    }
+    if (rf.img01Cnt < rf.maxCount and not rf.img01Lock) {
+      tgtCopy = xsc::COPY_1;
+      return;
+    }
+    if (rf.img00Lock) {
+      needsReboot = false;
+    }
+    // Reboot to fallback image
+  }
+  if ((CURRENT_CHIP == xsc::CHIP_1) and (CURRENT_COPY == xsc::COPY_1) and
+      (rf.img11Cnt >= rf.maxCount)) {
+    needsReboot = true;
+    if (rf.img10Cnt < rf.maxCount and not rf.img10Lock) {
+      tgtChip = xsc::CHIP_1;
+      return;
+    }
+    if (rf.img00Cnt < rf.maxCount and not rf.img00Lock) {
+      return;
+    }
+    if (rf.img01Cnt < rf.maxCount and not rf.img01Lock) {
+      tgtCopy = xsc::COPY_1;
+      return;
+    }
+    if (rf.img00Lock) {
+      needsReboot = false;
+    }
+    // Reboot to fallback image
+  }
+}
+
+bool CoreController::parseRebootFile(std::string path, RebootFile &rf) {
+  using namespace std;
+  std::string selfMatch;
+  if (CURRENT_CHIP == xsc::CHIP_0) {
+    if (CURRENT_COPY == xsc::COPY_0) {
+      selfMatch = "00";
+    } else {
+      selfMatch = "01";
+    }
+  } else {
+    if (CURRENT_COPY == xsc::COPY_0) {
+      selfMatch = "10";
+    } else {
+      selfMatch = "11";
+    }
+  }
+  ifstream file(path);
+  string word;
+  string line;
+  uint8_t lineIdx = 0;
+  while (std::getline(file, line)) {
+    istringstream iss(line);
+    switch (lineIdx) {
+      case 0: {
+        iss >> word;
+        if (word.find("on:") == string::npos) {
+          // invalid file
+          return false;
+        }
+        iss >> rf.enabled;
+        break;
+      }
+      case 1: {
+        iss >> word;
+        if (word.find("maxcnt:") == string::npos) {
+          return false;
+        }
+        iss >> rf.maxCount;
+        break;
+      }
+      case 2: {
+        iss >> word;
+        if (word.find("img00:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img00Cnt;
+        if (word.find(selfMatch) != string::npos) {
+          rf.relevantBootCnt = &rf.img00Cnt;
+        }
+        break;
+      }
+      case 3: {
+        iss >> word;
+        if (word.find("img01:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img01Cnt;
+        if (word.find(selfMatch) != string::npos) {
+          rf.relevantBootCnt = &rf.img01Cnt;
+        }
+        break;
+      }
+      case 4: {
+        iss >> word;
+        if (word.find("img10:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img10Cnt;
+        if (word.find(selfMatch) != string::npos) {
+          rf.relevantBootCnt = &rf.img10Cnt;
+        }
+        break;
+      }
+      case 5: {
+        iss >> word;
+        if (word.find("img11:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img11Cnt;
+        if (word.find(selfMatch) != string::npos) {
+          rf.relevantBootCnt = &rf.img11Cnt;
+        }
+        break;
+      }
+      case 6: {
+        iss >> word;
+        if (word.find("img00lock:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img00Lock;
+        break;
+      }
+      case 7: {
+        iss >> word;
+        if (word.find("img01lock:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img01Lock;
+        break;
+      }
+      case 8: {
+        iss >> word;
+        if (word.find("img10lock:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img10Lock;
+        break;
+      }
+      case 9: {
+        iss >> word;
+        if (word.find("img11lock:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img11Lock;
+        break;
+      }
+      case 10: {
+        iss >> word;
+        if (word.find("bootflag:") == string::npos) {
+          return false;
+        }
+        iss >> rf.bootFlag;
+        break;
+      }
+      case 11: {
+        iss >> word;
+        int copyRaw = 0;
+        int chipRaw = 0;
+        if (word.find("last:") == string::npos) {
+          return false;
+        }
+        iss >> chipRaw;
+        if (iss.fail()) {
+          return false;
+        }
+        iss >> copyRaw;
+        if (iss.fail()) {
+          return false;
+        }
+
+        if (chipRaw > 1 or copyRaw > 1) {
+          return false;
+        }
+        rf.lastChip = static_cast<xsc::Chip>(chipRaw);
+        rf.lastCopy = static_cast<xsc::Copy>(copyRaw);
+        break;
+      }
+      case 12: {
+        iss >> word;
+        int copyRaw = 0;
+        int chipRaw = 0;
+        if (word.find("next:") == string::npos) {
+          return false;
+        }
+        iss >> chipRaw;
+        if (iss.fail()) {
+          return false;
+        }
+        iss >> copyRaw;
+        if (iss.fail()) {
+          return false;
+        }
+
+        if (chipRaw > 2 or copyRaw > 2) {
+          return false;
+        }
+        rf.mechanismNextChip = static_cast<xsc::Chip>(chipRaw);
+        rf.mechanismNextCopy = static_cast<xsc::Copy>(copyRaw);
+        break;
+      }
+    }
+    if (iss.fail()) {
+      return false;
+    }
+    lineIdx++;
+  }
+  if (lineIdx < 12) {
+    return false;
+  }
+  return true;
+}
+
+void CoreController::resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy) {
+  std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+  // Disable the reboot file mechanism
+  parseRebootFile(path, rebootFile);
+  if (tgtChip == xsc::ALL_CHIP and tgtCopy == xsc::ALL_COPY) {
+    rebootFile.img00Cnt = 0;
+    rebootFile.img01Cnt = 0;
+    rebootFile.img10Cnt = 0;
+    rebootFile.img11Cnt = 0;
+  } else {
+    if (tgtChip == xsc::CHIP_0) {
+      if (tgtCopy == xsc::COPY_0) {
+        rebootFile.img00Cnt = 0;
+      } else {
+        rebootFile.img01Cnt = 0;
+      }
+    } else {
+      if (tgtCopy == xsc::COPY_0) {
+        rebootFile.img10Cnt = 0;
+      } else {
+        rebootFile.img11Cnt = 0;
+      }
+    }
+  }
+  rewriteRebootFile(rebootFile);
+}
+
+void CoreController::rewriteRebootFile(RebootFile file) {
+  std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+  std::ofstream rebootFile(path);
+  if (rebootFile.is_open()) {
+    // Initiate reboot file first. Reboot handling will be on on initialization
+    rebootFile << "on: " << file.enabled << "\nmaxcnt: " << file.maxCount
+               << "\nimg00: " << file.img00Cnt << "\nimg01: " << file.img01Cnt
+               << "\nimg10: " << file.img10Cnt << "\nimg11: " << file.img11Cnt
+               << "\nimg00lock: " << file.img00Lock << "\nimg01lock: " << file.img01Lock
+               << "\nimg10lock: " << file.img10Lock << "\nimg11lock: " << file.img11Lock
+               << "\nbootflag: " << file.bootFlag << "\nlast: " << static_cast<int>(file.lastChip)
+               << " " << static_cast<int>(file.lastCopy)
+               << "\nnext: " << static_cast<int>(file.mechanismNextChip) << " "
+               << static_cast<int>(file.mechanismNextCopy) << "\n";
+  }
+}
+
+void CoreController::setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy) {
+  std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+  // Disable the reboot file mechanism
+  parseRebootFile(path, rebootFile);
+  if (tgtChip == xsc::CHIP_0) {
+    if (tgtCopy == xsc::COPY_0) {
+      rebootFile.img00Lock = lock;
+    } else {
+      rebootFile.img01Lock = lock;
+    }
+  } else {
+    if (tgtCopy == xsc::COPY_0) {
+      rebootFile.img10Lock = lock;
+    } else {
+      rebootFile.img11Lock = lock;
+    }
+  }
+  rewriteRebootFile(rebootFile);
+}

bsp_q7s/core/CoreController.h

@@ -2,6 +2,9 @@
 #define BSP_Q7S_CORE_CORECONTROLLER_H_
 
 #include <fsfw/globalfunctions/PeriodicOperationDivider.h>
+#include <libxiphos.h>
+
+#include <cstddef>
 
 #include "bsp_q7s/memory/SdCardManager.h"
 #include "events/subsystemIdRanges.h"
@@ -10,24 +13,72 @@
 class Timer;
 class SdCardManager;
 
+namespace xsc {
+
+enum Chip : int { CHIP_0, CHIP_1, NO_CHIP, SELF_CHIP, ALL_CHIP };
+enum Copy : int { COPY_0, COPY_1, NO_COPY, SELF_COPY, ALL_COPY };
+
+}  // namespace xsc
+
+struct RebootFile {
+  static constexpr uint8_t DEFAULT_MAX_BOOT_CNT = 10;
+
+  bool enabled = true;
+  size_t maxCount = DEFAULT_MAX_BOOT_CNT;
+  uint32_t img00Cnt = 0;
+  uint32_t img01Cnt = 0;
+  uint32_t img10Cnt = 0;
+  uint32_t img11Cnt = 0;
+  bool img00Lock = false;
+  bool img01Lock = false;
+  bool img10Lock = false;
+  bool img11Lock = false;
+  uint32_t* relevantBootCnt = &img00Cnt;
+  bool bootFlag = false;
+  xsc::Chip lastChip = xsc::Chip::CHIP_0;
+  xsc::Copy lastCopy = xsc::Copy::COPY_0;
+  xsc::Chip mechanismNextChip = xsc::Chip::NO_CHIP;
+  xsc::Copy mechanismNextCopy = xsc::Copy::NO_COPY;
+};
+
 class CoreController : public ExtendedControllerBase {
  public:
-  enum Chip : uint8_t { CHIP_0, CHIP_1, NO_CHIP, SELF_CHIP, ALL_CHIP };
+  static xsc::Chip CURRENT_CHIP;
-
+  static xsc::Copy CURRENT_COPY;
-  enum Copy : uint8_t { COPY_0, COPY_1, NO_COPY, SELF_COPY, ALL_COPY };
 
   static constexpr char CHIP_PROT_SCRIPT[] = "/home/root/scripts/get-chip-prot-status.sh";
   static constexpr char CHIP_STATE_FILE[] = "/tmp/chip_prot_status.txt";
   static constexpr char CURR_COPY_FILE[] = "/tmp/curr_copy.txt";
-  static constexpr char VERSION_FILE[] = "/conf/sd_status";
+  static constexpr char CONF_FOLDER[] = "conf";
+  static constexpr char VERSION_FILE_NAME[] = "version.txt";
+  static constexpr char REBOOT_FILE_NAME[] = "reboot.txt";
+  const std::string VERSION_FILE =
+      "/" + std::string(CONF_FOLDER) + "/" + std::string(VERSION_FILE_NAME);
+  const std::string REBOOT_FILE =
+      "/" + std::string(CONF_FOLDER) + "/" + std::string(REBOOT_FILE_NAME);
 
   static constexpr ActionId_t LIST_DIRECTORY_INTO_FILE = 0;
+  static constexpr ActionId_t SWITCH_REBOOT_FILE_HANDLING = 5;
+  static constexpr ActionId_t RESET_REBOOT_COUNTERS = 6;
+  static constexpr ActionId_t SWITCH_IMG_LOCK = 7;
+  static constexpr ActionId_t SET_MAX_REBOOT_CNT = 8;
+
   static constexpr ActionId_t REBOOT_OBC = 32;
   static constexpr ActionId_t MOUNT_OTHER_COPY = 33;
 
   static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CORE;
 
   static constexpr Event ALLOC_FAILURE = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
+  //! [EXPORT] : [COMMENT]  Software reboot occured. Can also be a systemd reboot.
+  //! P1: Current Chip, P2: Current Copy
+  static constexpr Event REBOOT_SW = event::makeEvent(SUBSYSTEM_ID, 1, severity::MEDIUM);
+  //! [EXPORT] : [COMMENT] The reboot mechanism was triggered.
+  //! P1: First 16 bits: Last Chip, Last 16 bits: Last Copy,
+  //! P2: Each byte is the respective reboot count for the slots
+  static constexpr Event REBOOT_MECHANISM_TRIGGERED =
+      event::makeEvent(SUBSYSTEM_ID, 2, severity::MEDIUM);
+  //! Trying to find a way how to determine that the reboot came from ProASIC3 or PCDU..
+  static constexpr Event REBOOT_HW = event::makeEvent(SUBSYSTEM_ID, 3, severity::MEDIUM);
 
   CoreController(object_id_t objectId);
   virtual ~CoreController();
@@ -48,7 +99,7 @@ class CoreController : public ExtendedControllerBase {
    */
   static ReturnValue_t generateChipStateFile();
   static ReturnValue_t incrementAllocationFailureCount();
-  static void getCurrentBootCopy(Chip& chip, Copy& copy);
+  static void getCurrentBootCopy(xsc::Chip& chip, xsc::Copy& copy);
 
   ReturnValue_t updateProtInfo(bool regenerateChipStateFile = true);
 
@@ -63,15 +114,12 @@ class CoreController : public ExtendedControllerBase {
    * @param updateProtFile Specify whether the protection info file is updated
    * @return
    */
-  ReturnValue_t setBootCopyProtection(Chip targetChip, Copy targetCopy, bool protect,
+  ReturnValue_t setBootCopyProtection(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
                                       bool& protOperationPerformed, bool updateProtFile = true);
 
   bool sdInitFinished() const;
 
  private:
-  static Chip CURRENT_CHIP;
-  static Copy CURRENT_COPY;
-
   // Designated value for rechecking FIFO open
   static constexpr int RETRY_FIFO_OPEN = -2;
   int watchdogFifoFd = 0;
@@ -120,8 +168,9 @@ class CoreController : public ExtendedControllerBase {
     sd::SdState currentlyCommandedState = sd::SdState::OFF;
     sd::SdCard commandedCard = sd::SdCard::NONE;
     sd::SdState commandedState = sd::SdState::OFF;
-  };
+  } sdInfo;
-  SdInfo sdInfo;
+  RebootFile rebootFile = {};
+  bool doPerformMountedSdCardOps = true;
 
   /**
    * Index 0: Chip 0 Copy 0
@@ -136,7 +185,7 @@ class CoreController : public ExtendedControllerBase {
                                         LocalDataPoolManager& poolManager) override;
   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 initBootCopy();
   ReturnValue_t initWatchdogFifo();
@@ -148,10 +197,12 @@ class CoreController : public ExtendedControllerBase {
   ReturnValue_t sdCardSetup(sd::SdCard sdCard, sd::SdState targetState, std::string sdChar,
                             bool printOutput = true);
   ReturnValue_t sdColdRedundantBlockingInit();
+
   void currentStateSetter(sd::SdCard sdCard, sd::SdState newState);
   void determinePreferredSdCard();
   void executeNextExternalSdCommand();
   void checkExternalSdCommandStatus();
+  void performRebootFileHandling(bool recreateFile);
 
   ReturnValue_t actionListDirectoryIntoFile(ActionId_t actionId, MessageQueueId_t commandedBy,
                                             const uint8_t* data, size_t size);
@@ -160,9 +211,15 @@ class CoreController : public ExtendedControllerBase {
   void performWatchdogControlOperation();
 
   ReturnValue_t handleProtInfoUpdateLine(std::string nextLine);
-  int handleBootCopyProtAtIndex(Chip targetChip, Copy targetCopy, bool protect,
+  int handleBootCopyProtAtIndex(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
                                 bool& protOperationPerformed, bool selfChip, bool selfCopy,
                                 bool allChips, bool allCopies, uint8_t arrIdx);
+  void determineAndExecuteReboot(RebootFile& rf, bool& needsReboot, xsc::Chip& tgtChip,
+                                 xsc::Copy& tgtCopy);
+  void resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy);
+  void setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy);
+  bool parseRebootFile(std::string path, RebootFile& file);
+  void rewriteRebootFile(RebootFile file);
 };
 
 #endif /* BSP_Q7S_CORE_CORECONTROLLER_H_ */

bsp_q7s/memory/SdCardManager.cpp

@@ -7,6 +7,7 @@
 #include <fstream>
 #include <memory>
 
+#include "common/config/commonObjects.h"
 #include "fsfw/ipc/MutexFactory.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "linux/utility/utility.h"
@@ -14,7 +15,7 @@
 
 SdCardManager* SdCardManager::factoryInstance = nullptr;
 
-SdCardManager::SdCardManager() : cmdExecutor(256) {}
+SdCardManager::SdCardManager() : SystemObject(objects::SDC_MANAGER), cmdExecutor(256) {}
 
 SdCardManager::~SdCardManager() {}
 

bsp_q7s/memory/SdCardManager.h

@@ -1,6 +1,7 @@
 #ifndef BSP_Q7S_MEMORY_SDCARDACCESSMANAGER_H_
 #define BSP_Q7S_MEMORY_SDCARDACCESSMANAGER_H_
 
+#include <fsfw/objectmanager/SystemObject.h>
 #include <poll.h>
 
 #include <array>
@@ -22,7 +23,7 @@ class MutexIF;
  * @brief   Manages handling of SD cards like switching them on or off or getting the current
  *          state
  */
-class SdCardManager {
+class SdCardManager : public SystemObject {
   friend class SdCardAccess;
 
  public:
@@ -54,6 +55,7 @@ class SdCardManager {
   static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::FILE_SYSTEM;
 
   static constexpr Event SANITIZATION_FAILED = event::makeEvent(SUBSYSTEM_ID, 0, severity::LOW);
+  static constexpr Event MOUNTED_SD_CARD = event::makeEvent(SUBSYSTEM_ID, 1, severity::INFO);
 
   // C++17 does not support constexpr std::string yet
   static constexpr char SD_0_DEV_NAME[] = "/dev/mmcblk0p1";
@@ -183,7 +185,7 @@ class SdCardManager {
   /**
    * @brief   Checks if an SD card is mounted
    *
-   * @param sdCard    The SD crad to check
+   * @param sdCard    The SD card to check
    *
    * @return  true if mounted, otherwise false
    */

cmake/Q7SCrossCompileConfig.cmake

@@ -81,12 +81,23 @@ set(CMAKE_PREFIX_PATH
 	# "${SYSROOT_PATH}/usr/lib/${CROSS_COMPILE}"
 )
 
+set(C_FLAGS
+    -mcpu=cortex-a9
+    -mfpu=neon-vfpv3
+    -mfloat-abi=hard
+    ${COMMON_FLAGS}
+    -lgpiod
+    -lxiphos
+)
+
+string (REPLACE ";" " " C_FLAGS "${C_FLAGS}")
+
 set(CMAKE_C_FLAGS 
-	"-mcpu=cortex-a9 -mfpu=neon-vfpv3 -mfloat-abi=hard ${COMMON_FLAGS} -lgpiod" 
+    ${C_FLAGS}
 	CACHE STRING "C flags for Q7S"
 )
 set(CMAKE_CXX_FLAGS 
-	"${CMAKE_C_FLAGS}" 
+	"${CMAKE_C_FLAGS}"
 	CACHE STRING "CPP flags for Q7S"
 )
 

common/config/commonSubsystemIds.h

@@ -19,6 +19,7 @@ enum: uint8_t {
 	PLOC_MEMORY_DUMPER = 118,
 	PDEC_HANDLER = 119,
 	STR_HELPER = 120,
+	PL_PCDU_HANDLER = 121,
 	COMMON_SUBSYSTEM_ID_END
 };
 }

fsfw

@@ -1 +1 @@
-Subproject commit e05e203c83825b4069bb1391005d46f041b08455
+Subproject commit 6e0b90696da2dfd2ec4749dfdb73950be2283c25

generators/fsfwgen

@@ -1 +1 @@
-Subproject commit 636670f7a0075533974ca0a668efa9b623a52749
+Subproject commit bd76760052482f6f8fcdd84b88da963e61c9a48c

scripts/apply-clang-format.sh

@@ -10,3 +10,5 @@ find ./bsp_linux_board -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-fo
 find ./bsp_hosted -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
 find ./bsp_egse -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
 find ./test -iname *.h -o -iname *.cpp -o -iname *.c | xargs clang-format --style=file -i
+find ./unittest -iname *.h -o -iname *.cpp -o -iname *.c -o -type d -name build -prune | \
+	xargs clang-format --style=file -i

thirdparty/arcsec_star_tracker

@@ -1 +1 @@
-Subproject commit 7cb426a6a1f1b25ac02d7bfd0792c412451c70af
+Subproject commit b1594df9303056456604726592635d8a1c987e75

unittest/main.cpp

@@ -2,6 +2,5 @@
 #include "fsfw_tests/unit/CatchRunner.h"
 
 int main(int argc, char* argv[]) {
-    // fsfwtest::customMain(argc, argv);
+  // fsfwtest::customMain(argc, argv);
 }
-

unittest/rebootLogic/.gitignore

@@ -0,0 +1,2 @@
+/build
+c_cpp_properties.json

unittest/rebootLogic/.vscode/settings.json

@@ -0,0 +1,51 @@
+{
+    "editor.tabSize": 2,
+    "files.associations": {
+        "iosfwd": "cpp",
+        "array": "cpp",
+        "*.tcc": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "codecvt": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "fstream": "cpp",
+        "functional": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "optional": "cpp",
+        "ostream": "cpp",
+        "ratio": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "type_traits": "cpp",
+        "tuple": "cpp",
+        "typeinfo": "cpp",
+        "utility": "cpp",
+        "variant": "cpp",
+        "filesystem": "cpp",
+        "queue": "cpp"
+    }
+}

unittest/rebootLogic/CMakeLists.txt

@@ -0,0 +1,29 @@
+cmake_minimum_required(VERSION 3.13.0)
+project(reboot-logic VERSION 0.1.0)
+
+include(CTest)
+find_package(Catch2 3)
+if(NOT Catch2_FOUND)
+    include(FetchContent)
+
+    FetchContent_Declare(
+        Catch2
+        GIT_REPOSITORY https://github.com/catchorg/Catch2.git
+        GIT_TAG        v3.0.0-preview4
+    )
+
+    FetchContent_MakeAvailable(Catch2)
+    #fixes regression -preview4, to be confirmed in later releases
+    set_target_properties(Catch2 PROPERTIES DEBUG_POSTFIX "")
+endif()
+
+enable_testing()
+
+add_executable(reboot-logic)
+
+add_subdirectory(src)
+target_link_libraries(reboot-logic PRIVATE Catch2::Catch2WithMain)
+
+set(CPACK_PROJECT_NAME ${PROJECT_NAME})
+set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
+include(CPack)

unittest/rebootLogic/README.md

@@ -0,0 +1,16 @@
+Reboot Logic Unittest
+=======
+
+These tests were written with Catch2 and VS code.
+Install VS code with the C++ and CMake plugins and open this folder with VS code.
+You should be able to run the tests directly.
+
+It is also recommended to [install Catch2](https://github.com/catchorg/Catch2/blob/devel/docs/cmake-integration.md):
+
+```sh
+git clone https://github.com/catchorg/Catch2.git
+cd Catch2
+git checkout v3.0.0-preview4
+cmake -Bbuild -H. -DBUILD_TESTING=OFF
+sudo cmake --build build/ --target install
+```

unittest/rebootLogic/src/CMakeLists.txt

@@ -0,0 +1,14 @@
+target_sources(reboot-logic PRIVATE
+    main.cpp
+    CoreController.cpp
+    SdCardManager.cpp
+    event.cpp
+    libxiphos.cpp
+    print.c
+)
+
+target_include_directories(reboot-logic PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)
+
+add_subdirectory(fsfw)

unittest/rebootLogic/src/CoreController.cpp

@@ -0,0 +1,529 @@
+#include "CoreController.h"
+
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+
+#include "HasActionsIF.h"
+#include "SdCardManager.h"
+#include "conf.h"
+#include "event.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "libxiphos.h"
+
+xsc::Chip CoreController::CURRENT_CHIP = xsc::Chip::NO_CHIP;
+xsc::Copy CoreController::CURRENT_COPY = xsc::Copy::NO_COPY;
+
+CoreController::CoreController() {
+  sdcMan = new SdCardManager();
+  setCurrentBootCopy(xsc::CHIP_0, xsc::COPY_0);
+}
+
+void CoreController::performRebootFileHandling(bool recreateFile) {
+  using namespace std;
+  std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+  if (not std::filesystem::exists(path) or recreateFile) {
+#if OBSW_VERBOSE_LEVEL >= 1
+    sif::info << "CoreController::performRebootFileHandling: Recreating reboot file" << std::endl;
+#endif
+    rebootFile.enabled = true;
+    rebootFile.img00Cnt = 0;
+    rebootFile.img01Cnt = 0;
+    rebootFile.img10Cnt = 0;
+    rebootFile.img11Cnt = 0;
+    rebootFile.lastChip = xsc::Chip::CHIP_0;
+    rebootFile.lastCopy = xsc::Copy::COPY_0;
+    rebootFile.img00Lock = false;
+    rebootFile.img01Lock = false;
+    rebootFile.img10Lock = false;
+    rebootFile.img11Lock = false;
+    rebootFile.mechanismNextChip = xsc::Chip::NO_CHIP;
+    rebootFile.mechanismNextCopy = xsc::Copy::NO_COPY;
+    rebootFile.bootFlag = false;
+    rewriteRebootFile(rebootFile);
+  } else {
+    if (not parseRebootFile(path, rebootFile)) {
+      performRebootFileHandling(true);
+    }
+  }
+
+  if (CURRENT_CHIP == xsc::CHIP_0) {
+    if (CURRENT_COPY == xsc::COPY_0) {
+      rebootFile.img00Cnt++;
+    } else {
+      rebootFile.img01Cnt++;
+    }
+  } else {
+    if (CURRENT_COPY == xsc::COPY_0) {
+      rebootFile.img10Cnt++;
+    } else {
+      rebootFile.img11Cnt++;
+    }
+  }
+
+  if (rebootFile.bootFlag) {
+    // Trigger event to inform ground that a reboot was triggered
+    uint32_t p1 = rebootFile.lastChip << 16 | rebootFile.lastCopy;
+    uint32_t p2 = rebootFile.img00Cnt << 24 | rebootFile.img01Cnt << 16 | rebootFile.img10Cnt << 8 |
+                  rebootFile.img11Cnt;
+    triggerEvent(REBOOT_MECHANISM_TRIGGERED, p1, p2);
+    // Clear the boot flag
+    rebootFile.bootFlag = false;
+  }
+
+  if (rebootFile.mechanismNextChip != xsc::NO_CHIP and
+      rebootFile.mechanismNextCopy != xsc::NO_COPY) {
+    if (CURRENT_CHIP != rebootFile.mechanismNextChip or
+        CURRENT_COPY != rebootFile.mechanismNextCopy) {
+      std::string infoString = std::to_string(rebootFile.mechanismNextChip) + " " +
+                               std::to_string(rebootFile.mechanismNextCopy);
+      sif::warning << "CoreController::performRebootFileHandling: Expected to be on image "
+                   << infoString << " but currently on other image. Locking " << infoString
+                   << std::endl;
+      // Firmware or other component might be corrupt and we are on another image then the target
+      // image specified by the mechanism. We can't really trust the target image anymore.
+      // Lock it for now
+      if (rebootFile.mechanismNextChip == xsc::CHIP_0) {
+        if (rebootFile.mechanismNextCopy == xsc::COPY_0) {
+          rebootFile.img00Lock = true;
+        } else {
+          rebootFile.img01Lock = true;
+        }
+      } else {
+        if (rebootFile.mechanismNextCopy == xsc::COPY_0) {
+          rebootFile.img10Lock = true;
+        } else {
+          rebootFile.img11Lock = true;
+        }
+      }
+    }
+  }
+
+  rebootFile.lastChip = CURRENT_CHIP;
+  rebootFile.lastCopy = CURRENT_COPY;
+  // Only reboot if the reboot functionality is enabled.
+  // The handler will still increment the boot counts
+  if (rebootFile.enabled and (*rebootFile.relevantBootCnt >= rebootFile.maxCount)) {
+    // Reboot to other image
+    bool doReboot = false;
+    xsc::Chip tgtChip = xsc::NO_CHIP;
+    xsc::Copy tgtCopy = xsc::NO_COPY;
+    determineAndExecuteReboot(rebootFile, doReboot, tgtChip, tgtCopy);
+    if (doReboot) {
+      rebootFile.bootFlag = true;
+#if OBSW_VERBOSE_LEVEL >= 1
+      sif::info << "Boot counter for image " << CURRENT_CHIP << " " << CURRENT_COPY
+                << " too high. Rebooting to " << tgtChip << " " << tgtCopy << std::endl;
+#endif
+      rebootFile.mechanismNextChip = tgtChip;
+      rebootFile.mechanismNextCopy = tgtCopy;
+      rewriteRebootFile(rebootFile);
+      xsc_boot_copy(static_cast<xsc_libnor_chip_t>(tgtChip),
+                    static_cast<xsc_libnor_copy_t>(tgtCopy));
+    }
+  } else {
+    rebootFile.mechanismNextChip = xsc::NO_CHIP;
+    rebootFile.mechanismNextCopy = xsc::NO_COPY;
+  }
+  rewriteRebootFile(rebootFile);
+}
+
+void CoreController::determineAndExecuteReboot(RebootFile &rf, bool &needsReboot,
+                                               xsc::Chip &tgtChip, xsc::Copy &tgtCopy) {
+  tgtChip = xsc::CHIP_0;
+  tgtCopy = xsc::COPY_0;
+  needsReboot = false;
+  if ((CURRENT_CHIP == xsc::CHIP_0) and (CURRENT_COPY == xsc::COPY_0) and
+      (rf.img00Cnt >= rf.maxCount)) {
+    needsReboot = true;
+    if (rf.img01Cnt < rf.maxCount and not rf.img01Lock) {
+      tgtCopy = xsc::COPY_1;
+      return;
+    }
+    if (rf.img10Cnt < rf.maxCount and not rf.img10Lock) {
+      tgtChip = xsc::CHIP_1;
+      return;
+    }
+    if (rf.img11Cnt < rf.maxCount and not rf.img11Lock) {
+      tgtChip = xsc::CHIP_1;
+      tgtCopy = xsc::COPY_1;
+      return;
+    }
+    // Can't really do much here. Stay on image
+    sif::warning
+        << "All reboot counts too high or all fallback images locked, already on fallback image"
+        << std::endl;
+    needsReboot = false;
+    return;
+  }
+  if ((CURRENT_CHIP == xsc::CHIP_0) and (CURRENT_COPY == xsc::COPY_1) and
+      (rf.img01Cnt >= rf.maxCount)) {
+    needsReboot = true;
+    if (rf.img00Cnt < rf.maxCount and not rf.img00Lock) {
+      // Reboot on fallback image
+      return;
+    }
+    if (rf.img10Cnt < rf.maxCount and not rf.img10Lock) {
+      tgtChip = xsc::CHIP_1;
+      return;
+    }
+    if (rf.img11Cnt < rf.maxCount and not rf.img11Lock) {
+      tgtChip = xsc::CHIP_1;
+      tgtCopy = xsc::COPY_1;
+    }
+    if (rf.img00Lock) {
+      needsReboot = false;
+    }
+    // Reboot to fallback image
+  }
+  if ((CURRENT_CHIP == xsc::CHIP_1) and (CURRENT_COPY == xsc::COPY_0) and
+      (rf.img10Cnt >= rf.maxCount)) {
+    needsReboot = true;
+    if (rf.img11Cnt < rf.maxCount and not rf.img11Lock) {
+      tgtChip = xsc::CHIP_1;
+      tgtCopy = xsc::COPY_1;
+      return;
+    }
+    if (rf.img00Cnt < rf.maxCount and not rf.img00Lock) {
+      return;
+    }
+    if (rf.img01Cnt < rf.maxCount and not rf.img01Lock) {
+      tgtCopy = xsc::COPY_1;
+      return;
+    }
+    if (rf.img00Lock) {
+      needsReboot = false;
+    }
+    // Reboot to fallback image
+  }
+  if ((CURRENT_CHIP == xsc::CHIP_1) and (CURRENT_COPY == xsc::COPY_1) and
+      (rf.img11Cnt >= rf.maxCount)) {
+    needsReboot = true;
+    if (rf.img10Cnt < rf.maxCount and not rf.img10Lock) {
+      tgtChip = xsc::CHIP_1;
+      return;
+    }
+    if (rf.img00Cnt < rf.maxCount and not rf.img00Lock) {
+      return;
+    }
+    if (rf.img01Cnt < rf.maxCount and not rf.img01Lock) {
+      tgtCopy = xsc::COPY_1;
+      return;
+    }
+    if (rf.img00Lock) {
+      needsReboot = false;
+    }
+    // Reboot to fallback image
+  }
+}
+
+bool CoreController::parseRebootFile(std::string path, RebootFile &rf) {
+  using namespace std;
+  std::string selfMatch;
+  if (CURRENT_CHIP == xsc::CHIP_0) {
+    if (CURRENT_COPY == xsc::COPY_0) {
+      selfMatch = "00";
+    } else {
+      selfMatch = "01";
+    }
+  } else {
+    if (CURRENT_COPY == xsc::COPY_0) {
+      selfMatch = "10";
+    } else {
+      selfMatch = "11";
+    }
+  }
+  ifstream file(path);
+  string word;
+  string line;
+  uint8_t lineIdx = 0;
+  while (std::getline(file, line)) {
+    istringstream iss(line);
+    switch (lineIdx) {
+      case 0: {
+        iss >> word;
+        if (word.find("on:") == string::npos) {
+          // invalid file
+          return false;
+        }
+        iss >> rf.enabled;
+        break;
+      }
+      case 1: {
+        iss >> word;
+        if (word.find("maxcnt:") == string::npos) {
+          return false;
+        }
+        iss >> rf.maxCount;
+        break;
+      }
+      case 2: {
+        iss >> word;
+        if (word.find("img00:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img00Cnt;
+        if (word.find(selfMatch) != string::npos) {
+          rf.relevantBootCnt = &rf.img00Cnt;
+        }
+        break;
+      }
+      case 3: {
+        iss >> word;
+        if (word.find("img01:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img01Cnt;
+        if (word.find(selfMatch) != string::npos) {
+          rf.relevantBootCnt = &rf.img01Cnt;
+        }
+        break;
+      }
+      case 4: {
+        iss >> word;
+        if (word.find("img10:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img10Cnt;
+        if (word.find(selfMatch) != string::npos) {
+          rf.relevantBootCnt = &rf.img10Cnt;
+        }
+        break;
+      }
+      case 5: {
+        iss >> word;
+        if (word.find("img11:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img11Cnt;
+        if (word.find(selfMatch) != string::npos) {
+          rf.relevantBootCnt = &rf.img11Cnt;
+        }
+        break;
+      }
+      case 6: {
+        iss >> word;
+        if (word.find("img00lock:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img00Lock;
+        break;
+      }
+      case 7: {
+        iss >> word;
+        if (word.find("img01lock:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img01Lock;
+        break;
+      }
+      case 8: {
+        iss >> word;
+        if (word.find("img10lock:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img10Lock;
+        break;
+      }
+      case 9: {
+        iss >> word;
+        if (word.find("img11lock:") == string::npos) {
+          return false;
+        }
+        iss >> rf.img11Lock;
+        break;
+      }
+      case 10: {
+        iss >> word;
+        if (word.find("bootflag:") == string::npos) {
+          return false;
+        }
+        iss >> rf.bootFlag;
+        break;
+      }
+      case 11: {
+        iss >> word;
+        int copyRaw = 0;
+        int chipRaw = 0;
+        if (word.find("last:") == string::npos) {
+          return false;
+        }
+        iss >> chipRaw;
+        if (iss.fail()) {
+          return false;
+        }
+        iss >> copyRaw;
+        if (iss.fail()) {
+          return false;
+        }
+
+        if (chipRaw > 1 or copyRaw > 1) {
+          return false;
+        }
+        rf.lastChip = static_cast<xsc::Chip>(chipRaw);
+        rf.lastCopy = static_cast<xsc::Copy>(copyRaw);
+        break;
+      }
+      case 12: {
+        iss >> word;
+        int copyRaw = 0;
+        int chipRaw = 0;
+        if (word.find("next:") == string::npos) {
+          return false;
+        }
+        iss >> chipRaw;
+        if (iss.fail()) {
+          return false;
+        }
+        iss >> copyRaw;
+        if (iss.fail()) {
+          return false;
+        }
+
+        if (chipRaw > 2 or copyRaw > 2) {
+          return false;
+        }
+        rf.mechanismNextChip = static_cast<xsc::Chip>(chipRaw);
+        rf.mechanismNextCopy = static_cast<xsc::Copy>(copyRaw);
+        break;
+      }
+    }
+    if (iss.fail()) {
+      return false;
+    }
+    lineIdx++;
+  }
+  if (lineIdx < 12) {
+    return false;
+  }
+  return true;
+}
+
+void CoreController::resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy) {
+  std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+  // Disable the reboot file mechanism
+  parseRebootFile(path, rebootFile);
+  if (tgtChip == xsc::ALL_CHIP and tgtCopy == xsc::ALL_COPY) {
+    rebootFile.img00Cnt = 0;
+    rebootFile.img01Cnt = 0;
+    rebootFile.img10Cnt = 0;
+    rebootFile.img11Cnt = 0;
+  } else {
+    if (tgtChip == xsc::CHIP_0) {
+      if (tgtCopy == xsc::COPY_0) {
+        rebootFile.img00Cnt = 0;
+      } else {
+        rebootFile.img01Cnt = 0;
+      }
+    } else {
+      if (tgtCopy == xsc::COPY_0) {
+        rebootFile.img10Cnt = 0;
+      } else {
+        rebootFile.img11Cnt = 0;
+      }
+    }
+  }
+  rewriteRebootFile(rebootFile);
+}
+
+void CoreController::rewriteRebootFile(RebootFile file) {
+  std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+  std::ofstream rebootFile(path);
+  if (rebootFile.is_open()) {
+    // Initiate reboot file first. Reboot handling will be on on initialization
+    rebootFile << "on: " << file.enabled << "\nmaxcnt: " << file.maxCount
+               << "\nimg00: " << file.img00Cnt << "\nimg01: " << file.img01Cnt
+               << "\nimg10: " << file.img10Cnt << "\nimg11: " << file.img11Cnt
+               << "\nimg00lock: " << file.img00Lock << "\nimg01lock: " << file.img01Lock
+               << "\nimg10lock: " << file.img10Lock << "\nimg11lock: " << file.img11Lock
+               << "\nbootflag: " << file.bootFlag << "\nlast: " << static_cast<int>(file.lastChip)
+               << " " << static_cast<int>(file.lastCopy)
+               << "\nnext: " << static_cast<int>(file.mechanismNextChip) << " "
+               << static_cast<int>(file.mechanismNextCopy) << "\n";
+  }
+}
+
+ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                                            const uint8_t *data, size_t size) {
+  switch (actionId) {
+    case (SWITCH_REBOOT_FILE_HANDLING): {
+      if (size < 1) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+      // Disable the reboot file mechanism
+      parseRebootFile(path, rebootFile);
+      if (data[0] == 0) {
+        rebootFile.enabled = false;
+        rewriteRebootFile(rebootFile);
+      } else if (data[0] == 1) {
+        rebootFile.enabled = true;
+        rewriteRebootFile(rebootFile);
+      } else {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
+    case (RESET_REBOOT_COUNTERS): {
+      if (size == 0) {
+        resetRebootCount(xsc::ALL_CHIP, xsc::ALL_COPY);
+      } else if (size == 2) {
+        if (data[0] > 1 or data[1] > 1) {
+          return HasActionsIF::INVALID_PARAMETERS;
+        }
+        resetRebootCount(static_cast<xsc::Chip>(data[0]), static_cast<xsc::Copy>(data[1]));
+      }
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
+    case (SWITCH_IMG_LOCK): {
+      if (size != 3) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      if (data[1] > 1 or data[2] > 1) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      setRebootMechanismLock(data[0], static_cast<xsc::Chip>(data[1]),
+                             static_cast<xsc::Copy>(data[2]));
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
+    case (SET_MAX_REBOOT_CNT): {
+      if (size < 1) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+      // Disable the reboot file mechanism
+      parseRebootFile(path, rebootFile);
+      rebootFile.maxCount = data[0];
+      rewriteRebootFile(rebootFile);
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
+    default: {
+      return HasActionsIF::INVALID_ACTION_ID;
+    }
+  }
+}
+
+void CoreController::setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy) {
+  std::string path = sdcMan->getCurrentMountPrefix(sdInfo.pref) + REBOOT_FILE;
+  // Disable the reboot file mechanism
+  parseRebootFile(path, rebootFile);
+  if (tgtChip == xsc::CHIP_0) {
+    if (tgtCopy == xsc::COPY_0) {
+      rebootFile.img00Lock = lock;
+    } else {
+      rebootFile.img01Lock = lock;
+    }
+  } else {
+    if (tgtCopy == xsc::COPY_0) {
+      rebootFile.img10Lock = lock;
+    } else {
+      rebootFile.img11Lock = lock;
+    }
+  }
+  rewriteRebootFile(rebootFile);
+}
+
+void CoreController::setCurrentBootCopy(xsc::Chip chip, xsc::Copy copy) {
+  CURRENT_CHIP = chip;
+  CURRENT_COPY = copy;
+}

unittest/rebootLogic/src/CoreController.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+#include "SdCardManager.h"
+#include "definitions.h"
+
+namespace xsc {
+
+enum Chip : int { CHIP_0, CHIP_1, NO_CHIP, SELF_CHIP, ALL_CHIP };
+enum Copy : int { COPY_0, COPY_1, NO_COPY, SELF_COPY, ALL_COPY };
+
+}  // namespace xsc
+
+struct RebootFile {
+  static constexpr uint8_t DEFAULT_MAX_BOOT_CNT = 10;
+
+  bool enabled = true;
+  size_t maxCount = DEFAULT_MAX_BOOT_CNT;
+  uint32_t img00Cnt = 0;
+  uint32_t img01Cnt = 0;
+  uint32_t img10Cnt = 0;
+  uint32_t img11Cnt = 0;
+  bool img00Lock = false;
+  bool img01Lock = false;
+  bool img10Lock = false;
+  bool img11Lock = false;
+  uint32_t* relevantBootCnt = &img00Cnt;
+  bool bootFlag = false;
+  xsc::Chip lastChip = xsc::Chip::CHIP_0;
+  xsc::Copy lastCopy = xsc::Copy::COPY_0;
+  xsc::Chip mechanismNextChip = xsc::Chip::NO_CHIP;
+  xsc::Copy mechanismNextCopy = xsc::Copy::NO_COPY;
+};
+
+class SdCardManager;
+
+class CoreController {
+ public:
+  static constexpr char REBOOT_FILE[] = "/conf/reboot.txt";
+  //! [EXPORT] : [COMMENT] The reboot mechanism was triggered.
+  //! P1: First 16 bits: Last Chip, Last 16 bits: Last Copy,
+  //! P2: Each byte is the respective reboot count for the slots
+  static constexpr Event REBOOT_MECHANISM_TRIGGERED = 1;
+  static xsc::Chip CURRENT_CHIP;
+  static xsc::Copy CURRENT_COPY;
+
+  static constexpr ActionId_t SWITCH_REBOOT_FILE_HANDLING = 5;
+  static constexpr ActionId_t RESET_REBOOT_COUNTERS = 6;
+  static constexpr ActionId_t SWITCH_IMG_LOCK = 7;
+  static constexpr ActionId_t SET_MAX_REBOOT_CNT = 8;
+
+  CoreController();
+
+  static void setCurrentBootCopy(xsc::Chip chip, xsc::Copy copy);
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                              const uint8_t* data, size_t size);
+  void performRebootFileHandling(bool recreateFile);
+  void determineAndExecuteReboot(RebootFile& rf, bool& needsReboot, xsc::Chip& tgtChip,
+                                 xsc::Copy& tgtCopy);
+  void setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy);
+  void resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy);
+  bool parseRebootFile(std::string path, RebootFile& file);
+  void rewriteRebootFile(RebootFile file);
+
+ private:
+  struct SdInfo {
+    sd::SdCard pref = sd::SdCard::NONE;
+    sd::SdState prefState = sd::SdState::OFF;
+    sd::SdCard other = sd::SdCard::NONE;
+    sd::SdState otherState = sd::SdState::OFF;
+  } sdInfo;
+
+  SdCardManager* sdcMan = nullptr;
+  RebootFile rebootFile = {};
+  bool doPerformRebootFileHandling = true;
+};

unittest/rebootLogic/src/HasActionsIF.h

@@ -0,0 +1,9 @@
+#include "definitions.h"
+
+class HasActionsIF {
+ public:
+  static const ReturnValue_t IS_BUSY = 1;
+  static const ReturnValue_t INVALID_PARAMETERS = 2;
+  static const ReturnValue_t EXECUTION_FINISHED = 3;
+  static const ReturnValue_t INVALID_ACTION_ID = 4;
+};

unittest/rebootLogic/src/SdCardManager.cpp

@@ -0,0 +1,5 @@
+#include "SdCardManager.h"
+
+std::string SdCardManager::getCurrentMountPrefix(sd::SdCard prefSdCard) { return "/tmp"; }
+
+bool SdCardManager::isSdCardMounted(sd::SdCard sdCard) { return true; }

unittest/rebootLogic/src/SdCardManager.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+namespace sd {
+
+enum SdState : uint8_t {
+  OFF = 0,
+  ON = 1,
+  // A mounted SD card is on as well
+  MOUNTED = 2
+};
+
+enum SdCard : uint8_t { SLOT_0 = 0, SLOT_1 = 1, BOTH, NONE };
+
+}  // namespace sd
+
+class SdCardManager {
+ public:
+  std::string getCurrentMountPrefix(sd::SdCard prefSdCard);
+  bool isSdCardMounted(sd::SdCard sdCard);
+};

unittest/rebootLogic/src/conf.h

@@ -0,0 +1 @@
+#define OBSW_VERBOSE_LEVEL 1

unittest/rebootLogic/src/definitions.h

@@ -0,0 +1,6 @@
+#include <cstdint>
+
+using Event = uint32_t;
+using ActionId_t = uint32_t;
+using MessageQueueId_t = uint32_t;
+using ReturnValue_t = uint16_t;

unittest/rebootLogic/src/event.cpp

@@ -0,0 +1,21 @@
+#include "event.h"
+
+#include <queue>
+
+std::queue<EventInfo> EVENT_QUEUE = {};
+
+void triggerEvent(Event event, uint32_t p1, uint32_t p2) {
+  EventInfo info = {};
+  info.event = event;
+  info.p1 = p1;
+  info.p2 = p2;
+  EVENT_QUEUE.push(info);
+}
+
+void eventWasCalled(EventInfo& eventInfo, uint32_t& numEvents) {
+  numEvents = EVENT_QUEUE.size();
+  if (not EVENT_QUEUE.empty()) {
+    eventInfo = std::move(EVENT_QUEUE.back());
+    EVENT_QUEUE.pop();
+  }
+}

unittest/rebootLogic/src/event.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <cstdint>
+#include <iostream>
+
+#include "definitions.h"
+
+struct EventInfo {
+  // That was just for testing, follow rule of 0
+  /*
+  EventInfo () {}
+
+  EventInfo (const EventInfo& other): event(other.event), p1(other.p1), p2(other.p2) {
+        std::cout << "Event info copy ctor called" << std::endl;
+  }
+
+  EventInfo &operator= (const EventInfo& other) {
+    std::cout << "Event info assignment ctor called" << std::endl;
+    this->event = other.event;
+    this->p1 = other.p1;
+    this->p2 = other.p2;
+    return *this;
+  }
+
+  EventInfo &operator= (EventInfo&& other) {
+    std::cout << "Event info move ctor called" << std::endl;
+    this->event = other.event;
+    this->p1 = other.p1;
+    this->p2 = other.p2;
+    return *this;
+  }
+  */
+
+  uint32_t event = 0;
+  uint32_t p1 = 0;
+  uint32_t p2 = 0;
+};
+
+void triggerEvent(Event event, uint32_t p1, uint32_t p2);
+
+void eventWasCalled(EventInfo& eventInfo, uint32_t& numEvents);

unittest/rebootLogic/src/fsfw/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(serviceinterface)

unittest/rebootLogic/src/fsfw/FSFW.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <cstddef>
+
+#define FSFW_CPP_OSTREAM_ENABLED 1
+
+namespace fsfwconfig {
+static constexpr size_t FSFW_PRINT_BUFFER_SIZE = 256;
+}

unittest/rebootLogic/src/fsfw/serviceinterface/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(reboot-logic PRIVATE
+  ServiceInterfaceStream.cpp
+  ServiceInterfaceBuffer.cpp
+)

unittest/rebootLogic/src/fsfw/serviceinterface/ServiceInterface.h

@@ -0,0 +1,13 @@
+#ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
+#define FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_
+
+#include "fsfw/FSFW.h"
+#include "serviceInterfaceDefintions.h"
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+#include "ServiceInterfaceStream.h"
+#else
+#include "ServiceInterfacePrinter.h"
+#endif
+
+#endif /* FSFW_SERVICEINTERFACE_SERVICEINTERFACE_H_ */

unittest/rebootLogic/src/fsfw/serviceinterface/ServiceInterfaceBuffer.cpp

@@ -0,0 +1,252 @@
+#include "ServiceInterfaceBuffer.h"
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+
+#include <inttypes.h>
+
+#include <cstring>
+
+#include "fsfw/serviceinterface/serviceInterfaceDefintions.h"
+
+#if defined(WIN32) && FSFW_COLORED_OUTPUT == 1
+#include "Windows.h"
+#endif
+
+// to be implemented by bsp
+extern "C" void printChar(const char*, bool errStream);
+
+#ifndef UT699
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble,
+                                               bool buffered, bool errStream, uint16_t port)
+    : isActive(true),
+      logMessage(setMessage),
+      addCrToPreamble(addCrToPreamble),
+      buffered(buffered),
+      errStream(errStream) {
+  if (buffered) {
+    // Set pointers if the stream is buffered.
+    setp(buf, buf + BUF_SIZE);
+  }
+
+#if FSFW_COLORED_OUTPUT == 1
+  if (setMessage.find("DEBUG") != std::string::npos) {
+    colorPrefix = sif::ANSI_COLOR_CYAN;
+  } else if (setMessage.find("INFO") != std::string::npos) {
+    colorPrefix = sif::ANSI_COLOR_GREEN;
+  } else if (setMessage.find("WARNING") != std::string::npos) {
+    colorPrefix = sif::ANSI_COLOR_MAGENTA;
+  } else if (setMessage.find("ERROR") != std::string::npos) {
+    colorPrefix = sif::ANSI_COLOR_RED;
+  } else {
+    colorPrefix = sif::ANSI_COLOR_RESET;
+  }
+
+#ifdef WIN32
+  HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+  DWORD dwMode = 0;
+  GetConsoleMode(hOut, &dwMode);
+  dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+  SetConsoleMode(hOut, dwMode);
+#endif
+
+#endif
+
+  preamble.reserve(MAX_PREAMBLE_SIZE);
+  preamble.resize(MAX_PREAMBLE_SIZE);
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+  char array[BUF_SIZE];
+  uint32_t length = end - begin;
+  if (length > sizeof(array)) {
+    length = sizeof(array);
+  }
+  memcpy(array, begin, length);
+
+  for (; begin != end; begin++) {
+    if (errStream) {
+      printChar(begin, true);
+    } else {
+      printChar(begin, false);
+    }
+  }
+}
+
+#endif
+
+int ServiceInterfaceBuffer::overflow(int c) {
+  if (not buffered and this->isActive) {
+    if (c != Traits::eof()) {
+      if (errStream) {
+        printChar(reinterpret_cast<const char*>(&c), true);
+      } else {
+        printChar(reinterpret_cast<const char*>(&c), false);
+      }
+    }
+    return 0;
+  }
+  // Handle output
+  putChars(pbase(), pptr());
+  if (c != Traits::eof()) {
+    char c2 = c;
+    // Handle the one character that didn't fit to buffer
+    putChars(&c2, &c2 + 1);
+  }
+  // This tells that buffer is empty again
+  setp(buf, buf + BUF_SIZE - 1);
+  // I'm not sure about this return value!
+  return 0;
+}
+
+int ServiceInterfaceBuffer::sync(void) {
+  if (not this->isActive and not buffered) {
+    if (not buffered) {
+      setp(buf, buf + BUF_SIZE - 1);
+    }
+    return 0;
+  }
+  if (not buffered) {
+    return 0;
+  }
+
+  size_t preambleSize = 0;
+  std::string* preamble = getPreamble(&preambleSize);
+  // Write logMessage and time
+  this->putChars(preamble->data(), preamble->data() + preambleSize);
+  // Handle output
+  this->putChars(pbase(), pptr());
+  // This tells that buffer is empty again
+  setp(buf, buf + BUF_SIZE - 1);
+  return 0;
+}
+
+bool ServiceInterfaceBuffer::isBuffered() const { return buffered; }
+
+std::string* ServiceInterfaceBuffer::getPreamble(size_t* preambleSize) {
+  size_t currentSize = 0;
+  char* parsePosition = &preamble[0];
+  if (addCrToPreamble) {
+    preamble[0] = '\r';
+    currentSize += 1;
+    parsePosition += 1;
+  }
+
+#if FSFW_COLORED_OUTPUT == 1
+  currentSize += sprintf(parsePosition, "%s", colorPrefix.c_str());
+  parsePosition += colorPrefix.size();
+#endif
+
+  int32_t charCount =
+      sprintf(parsePosition, "%s%s | ", this->logMessage.c_str(), sif::ANSI_COLOR_RESET);
+  if (charCount < 0) {
+    printf("ServiceInterfaceBuffer: Failure parsing preamble\r\n");
+    return &preamble;
+  }
+  if (charCount > MAX_PREAMBLE_SIZE) {
+    printf(
+        "ServiceInterfaceBuffer: Char count too large for maximum "
+        "preamble size");
+    return &preamble;
+  }
+  currentSize += charCount;
+  if (preambleSize != nullptr) {
+    *preambleSize = currentSize;
+  }
+  return &preamble;
+}
+
+bool ServiceInterfaceBuffer::crAdditionEnabled() const { return addCrToPreamble; }
+
+#if FSFW_COLORED_OUTPUT == 1
+void ServiceInterfaceBuffer::setAsciiColorPrefix(std::string colorPrefix) {
+  this->colorPrefix = colorPrefix;
+}
+#endif
+
+#ifdef UT699
+#include "../osal/rtems/Interrupt.h"
+
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port) {
+  this->log_message = set_message;
+  this->isActive = true;
+  setp(buf, buf + BUF_SIZE);
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+  char array[BUF_SIZE];
+  uint32_t length = end - begin;
+  if (length > sizeof(array)) {
+    length = sizeof(array);
+  }
+  memcpy(array, begin, length);
+
+  if (!Interrupt::isInterruptInProgress()) {
+    std::cout << array;
+  } else {
+    // Uncomment the following line if you need ISR debug output.
+    //		printk(array);
+  }
+}
+#endif  // UT699
+
+#ifdef ML505
+#include <bsp_flp/network/networkconfig.h>
+ServiceInterfaceBuffer::ServiceInterfaceBuffer(std::string set_message, uint16_t port)
+    : isActive(true),
+      log_message(set_message),
+      udpSocket(0),
+      remoteAddressLength(sizeof(remoteAddress)) {
+  setp(buf, buf + BUF_SIZE);
+  memset((uint8_t*)&remoteAddress, 0, sizeof(remoteAddress));
+  remoteAddress.sin_family = AF_INET;
+  remoteAddress.sin_port = htons(port);
+  remoteAddress.sin_addr.s_addr = htonl(inet_addr("192.168.250.100"));
+}
+
+void ServiceInterfaceBuffer::putChars(char const* begin, char const* end) {
+  char array[BUF_SIZE];
+  uint32_t length = end - begin;
+  if (length > sizeof(array)) {
+    length = sizeof(array);
+  }
+  memcpy(array, begin, length);
+
+  if (udpSocket <= 0) {
+    initSocket();
+  }
+
+  if (udpSocket > 0) {
+    sendto(udpSocket, array, length, 0, (sockaddr*)&remoteAddress, sizeof(remoteAddress));
+  }
+}
+
+void ServiceInterfaceBuffer::initSocket() {
+  sockaddr_in address;
+  memset((uint8_t*)&address, 0, sizeof(address));
+  address.sin_family = AF_INET;
+  address.sin_port = htons(0);
+  address.sin_addr.s_addr = htonl(INADDR_ANY);
+
+  udpSocket = socket(PF_INET, SOCK_DGRAM, 0);
+  if (socket < 0) {
+    printf("Error opening socket!\n");
+    return;
+  }
+  timeval timeout = {0, 20};
+  if (setsockopt(udpSocket, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) < 0) {
+    printf("Error setting SO_RCVTIMEO socket options!\n");
+    return;
+  }
+  if (setsockopt(udpSocket, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) < 0) {
+    printf("Error setting SO_SNDTIMEO socket options!\n");
+    return;
+  }
+  if (bind(udpSocket, (sockaddr*)&address, sizeof(address)) < 0) {
+    printf("Error binding socket!\n");
+  }
+}
+
+#endif  // ML505
+
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */

unittest/rebootLogic/src/fsfw/serviceinterface/ServiceInterfaceBuffer.h

@@ -0,0 +1,159 @@
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_
+
+#include "fsfw/FSFW.h"
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+
+#ifndef UT699
+
+/**
+ * @brief 	This is the underlying stream buffer which implements the
+ * 			streambuf class and overloads the overflow() and sync() methods
+ * @details
+ * This class is used to modify the output of the stream, for example by adding.
+ * It also calls the char printing function which is implemented in the
+ * board supply package (BSP).
+ */
+class ServiceInterfaceBuffer : public std::streambuf {
+  friend class ServiceInterfaceStream;
+
+ public:
+  static constexpr uint8_t MAX_PREAMBLE_SIZE = 40;
+
+  ServiceInterfaceBuffer(std::string setMessage, bool addCrToPreamble, bool buffered,
+                         bool errStream, uint16_t port);
+
+ protected:
+  bool isActive;
+  //! This is called when buffer becomes full. If
+  //! buffer is not used, then this is called every
+  //! time when characters are put to stream.
+  int overflow(int c = Traits::eof()) override;
+
+  //! This function is called when stream is flushed,
+  //! for example when std::endl is put to stream.
+  int sync(void) override;
+
+  bool isBuffered() const;
+
+ private:
+  //! For additional message information
+  std::string logMessage;
+  std::string preamble;
+
+#if FSFW_COLORED_OUTPUT == 1
+  std::string colorPrefix;
+  void setAsciiColorPrefix(std::string colorPrefix);
+#endif
+
+  // For EOF detection
+  typedef std::char_traits<char> Traits;
+
+  //! This is useful for some terminal programs which do not have
+  //! implicit carriage return with newline characters.
+  bool addCrToPreamble;
+
+  //! Specifies whether the stream operates in buffered or unbuffered mode.
+  bool buffered;
+  //! This specifies to print to stderr and work in unbuffered mode.
+  bool errStream;
+
+  //! Needed for buffered mode.
+  static size_t const BUF_SIZE = fsfwconfig::FSFW_PRINT_BUFFER_SIZE;
+  char buf[BUF_SIZE];
+
+  //! In this function, the characters are parsed.
+  void putChars(char const* begin, char const* end);
+
+  std::string* getPreamble(size_t* preambleSize = nullptr);
+
+  bool crAdditionEnabled() const;
+};
+
+#endif
+
+#ifdef UT699
+class ServiceInterfaceBuffer : public std::basic_streambuf<char, std::char_traits<char> > {
+  friend class ServiceInterfaceStream;
+
+ public:
+  ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+
+ protected:
+  bool isActive;
+  // This is called when buffer becomes full. If
+  // buffer is not used, then this is called every
+  // time when characters are put to stream.
+  virtual int overflow(int c = Traits::eof());
+
+  // This function is called when stream is flushed,
+  // for example when std::endl is put to stream.
+  virtual int sync(void);
+
+ private:
+  // For additional message information
+  std::string log_message;
+  // For EOF detection
+  typedef std::char_traits<char> Traits;
+
+  // Work in buffer mode. It is also possible to work without buffer.
+  static size_t const BUF_SIZE = 128;
+  char buf[BUF_SIZE];
+
+  // In this function, the characters are parsed.
+  void putChars(char const* begin, char const* end);
+};
+#endif  // UT699
+
+#ifdef ML505
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netinet/udp.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+class ServiceInterfaceBuffer : public std::basic_streambuf<char, std::char_traits<char> > {
+  friend class ServiceInterfaceStream;
+
+ public:
+  ServiceInterfaceBuffer(std::string set_message, uint16_t port);
+
+ protected:
+  bool isActive;
+  // This is called when buffer becomes full. If
+  // buffer is not used, then this is called every
+  // time when characters are put to stream.
+  virtual int overflow(int c = Traits::eof());
+
+  // This function is called when stream is flushed,
+  // for example when std::endl is put to stream.
+  virtual int sync(void);
+
+ private:
+  // For additional message information
+  std::string log_message;
+  // For EOF detection
+  typedef std::char_traits<char> Traits;
+
+  // Work in buffer mode. It is also possible to work without buffer.
+  static size_t const BUF_SIZE = 128;
+  char buf[BUF_SIZE];
+
+  // In this function, the characters are parsed.
+  void putChars(char const* begin, char const* end);
+
+  int udpSocket;
+  sockaddr_in remoteAddress;
+  socklen_t remoteAddressLength;
+  void initSocket();
+};
+#endif  // ML505
+
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+
+#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACEBUFFER_H_ */

unittest/rebootLogic/src/fsfw/serviceinterface/ServiceInterfaceStream.cpp

@@ -0,0 +1,21 @@
+#include "ServiceInterfaceStream.h"
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+
+ServiceInterfaceStream::ServiceInterfaceStream(std::string setMessage, bool addCrToPreamble,
+                                               bool buffered, bool errStream, uint16_t port)
+    : std::ostream(&streambuf), streambuf(setMessage, addCrToPreamble, buffered, errStream, port) {}
+
+void ServiceInterfaceStream::setActive(bool myActive) { this->streambuf.isActive = myActive; }
+
+std::string* ServiceInterfaceStream::getPreamble() { return streambuf.getPreamble(); }
+
+bool ServiceInterfaceStream::crAdditionEnabled() const { return streambuf.crAdditionEnabled(); }
+
+#if FSFW_COLORED_OUTPUT == 1
+void ServiceInterfaceStream::setAsciiColorPrefix(std::string asciiColorCode) {
+  streambuf.setAsciiColorPrefix(asciiColorCode);
+}
+#endif
+
+#endif

unittest/rebootLogic/src/fsfw/serviceinterface/ServiceInterfaceStream.h

@@ -0,0 +1,67 @@
+#ifndef FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+#define FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_
+
+#include "ServiceInterfaceBuffer.h"
+#include "fsfw/FSFW.h"
+
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+
+#include <cstdio>
+#include <iostream>
+
+/**
+ * Generic service interface stream which can be used like std::cout or
+ * std::cerr but has additional capability. Add preamble and timestamp
+ * to output. Can be run in buffered or unbuffered mode.
+ */
+class ServiceInterfaceStream : public std::ostream {
+ public:
+  /**
+   * This constructor is used by specifying the preamble message.
+   * Optionally, the output can be directed to stderr and a CR character
+   * can be prepended to the preamble.
+   * @param setMessage message of preamble.
+   * @param addCrToPreamble Useful for applications like Puttty.
+   * @param buffered specify whether to use buffered mode.
+   * @param errStream specify which output stream to use (stderr or stdout).
+   */
+  ServiceInterfaceStream(std::string setMessage, bool addCrToPreamble = false, bool buffered = true,
+                         bool errStream = false, uint16_t port = 1234);
+
+  //! An inactive stream will not print anything.
+  void setActive(bool);
+
+  /**
+   * This can be used to retrieve the preamble in case it should be printed in
+   * the unbuffered mode.
+   * @return Preamle consisting of log message and timestamp.
+   */
+  std::string* getPreamble();
+
+  /**
+   * Can be used to determine if the stream was configured to add CR characters in addition
+   * to newline characters.
+   * @return
+   */
+  bool crAdditionEnabled() const;
+
+#if FSFW_COLORED_OUTPUT == 1
+  void setAsciiColorPrefix(std::string asciiColorCode);
+#endif
+
+ protected:
+  ServiceInterfaceBuffer streambuf;
+};
+
+// Forward declaration of interface streams. These should be instantiated in
+// main. They can then be used like std::cout or std::cerr.
+namespace sif {
+extern ServiceInterfaceStream debug;
+extern ServiceInterfaceStream info;
+extern ServiceInterfaceStream warning;
+extern ServiceInterfaceStream error;
+}  // namespace sif
+
+#endif /* FSFW_CPP_OSTREAM_ENABLED == 1 */
+
+#endif /* FRAMEWORK_SERVICEINTERFACE_SERVICEINTERFACESTREAM_H_ */

unittest/rebootLogic/src/fsfw/serviceinterface/serviceInterfaceDefintions.h

@@ -0,0 +1,18 @@
+#ifndef FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
+#define FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_
+
+namespace sif {
+
+enum class OutputTypes { OUT_INFO, OUT_DEBUG, OUT_WARNING, OUT_ERROR };
+
+static const char* const ANSI_COLOR_RED = "\x1b[31m";
+static const char* const ANSI_COLOR_GREEN = "\x1b[32m";
+static const char* const ANSI_COLOR_YELLOW = "\x1b[33m";
+static const char* const ANSI_COLOR_BLUE = "\x1b[34m";
+static const char* const ANSI_COLOR_MAGENTA = "\x1b[35m";
+static const char* const ANSI_COLOR_CYAN = "\x1b[36m";
+static const char* const ANSI_COLOR_RESET = "\x1b[0m";
+
+}  // namespace sif
+
+#endif /* FSFW_SERVICEINTERFACE_SERVICEINTERFACEDEFINTIONS_H_ */

unittest/rebootLogic/src/libxiphos.cpp

@@ -0,0 +1,25 @@
+#include "libxiphos.h"
+
+#include "CoreController.h"
+
+bool rebootWasCalled = false;
+xsc_libnor_chip_t lastChip;
+xsc_libnor_copy_t lastCopy;
+
+bool getRebootWasCalled(xsc_libnor_chip_t& tgtChip, xsc_libnor_copy_t& tgtCopy) {
+  tgtChip = lastChip;
+  tgtCopy = lastCopy;
+  bool tmp = rebootWasCalled;
+  if (rebootWasCalled) {
+    rebootWasCalled = false;
+  }
+  return tmp;
+}
+
+void xsc_boot_copy(xsc_libnor_chip_t boot_chip, xsc_libnor_copy_t boot_copy) {
+  rebootWasCalled = true;
+  lastChip = boot_chip;
+  lastCopy = boot_copy;
+  CoreController::setCurrentBootCopy(static_cast<xsc::Chip>(boot_chip),
+                                     static_cast<xsc::Copy>(boot_copy));
+}

unittest/rebootLogic/src/libxiphos.h

@@ -0,0 +1,25 @@
+#pragma once
+
+/** Type for identifying the nominal or the gold (redundant) flash copy */
+typedef enum {
+  XSC_LIBNOR_COPY_NOMINAL,
+  XSC_LIBNOR_COPY_GOLD,
+  XSC_LIBNOR_COPY_TOTAL_NUMBER
+} xsc_libnor_copy_t;
+
+/** Type for identifying on of the two NOR flash chips */
+typedef enum {
+  XSC_LIBNOR_CHIP_0, /* First NOR flash chip */
+  XSC_LIBNOR_CHIP_1, /* Second NOR flash chip */
+  XSC_LIBNOR_CHIP_TOTAL_NUMBER
+} xsc_libnor_chip_t;
+
+/**
+ * @brief Used to verify whether reboot function was called
+ *
+ * @param tgtChip
+ * @param tgtCopy
+ */
+bool getRebootWasCalled(xsc_libnor_chip_t& tgtChip, xsc_libnor_copy_t& tgtCopy);
+
+void xsc_boot_copy(xsc_libnor_chip_t boot_chip, xsc_libnor_copy_t boot_copy);

unittest/rebootLogic/src/main.cpp

@@ -0,0 +1,413 @@
+#include <catch2/catch_test_macros.hpp>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+
+#include "CoreController.h"
+#include "HasActionsIF.h"
+#include "event.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "libxiphos.h"
+
+static constexpr bool CAT_FILE_TO_CONSOLE = false;
+const std::string CONF_PATH = "/tmp/conf";
+const std::string REBOOT_FILE = CONF_PATH + "/reboot.txt";
+
+void catFileToConsole();
+
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR", false, false, true);
+
+TEST_CASE("Core Controller Reboot File Handling", "[reboot-file]") {
+  if (not std::filesystem::exists(CONF_PATH)) {
+    std::filesystem::create_directory(CONF_PATH);
+  }
+  CoreController ctrl;
+  std::array<uint8_t, 12> cmdData = {};
+
+  SECTION("Primary") {
+    xsc_libnor_chip_t chip;
+    xsc_libnor_copy_t copy;
+    RebootFile rf = {};
+    ctrl.rewriteRebootFile(rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.maxCount == RebootFile::DEFAULT_MAX_BOOT_CNT);
+    REQUIRE(rf.img00Cnt == 0);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 0);
+    REQUIRE(rf.img11Cnt == 0);
+    REQUIRE(rf.bootFlag == 0);
+    REQUIRE(rf.lastChip == 0);
+    REQUIRE(rf.lastCopy == 0);
+    // This recreates the file but should also increment the boot counter of the current image
+    REQUIRE(ctrl.CURRENT_CHIP == xsc::CHIP_0);
+    REQUIRE(ctrl.CURRENT_COPY == xsc::COPY_0);
+    ctrl.performRebootFileHandling(true);
+    catFileToConsole();
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.maxCount == RebootFile::DEFAULT_MAX_BOOT_CNT);
+    REQUIRE(rf.img00Cnt == 1);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 0);
+    REQUIRE(rf.img11Cnt == 0);
+    REQUIRE(rf.bootFlag == 0);
+    REQUIRE(rf.lastChip == xsc::CHIP_0);
+    REQUIRE(rf.lastCopy == xsc::COPY_0);
+    uint8_t newRebootCnt = 3;
+    CHECK(ctrl.executeAction(CoreController::SET_MAX_REBOOT_CNT, 0, &newRebootCnt, 1) ==
+          HasActionsIF::EXECUTION_FINISHED);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.maxCount == 3);
+    REQUIRE(not getRebootWasCalled(chip, copy));
+    ctrl.performRebootFileHandling(false);
+    ctrl.performRebootFileHandling(false);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 3);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 0);
+    REQUIRE(rf.img11Cnt == 0);
+    REQUIRE(rf.bootFlag == true);
+    REQUIRE(rf.lastChip == xsc::CHIP_0);
+    REQUIRE(rf.lastCopy == xsc::COPY_0);
+    REQUIRE(getRebootWasCalled(chip, copy));
+    REQUIRE(chip == XSC_LIBNOR_CHIP_0);
+    REQUIRE(copy == XSC_LIBNOR_COPY_GOLD);
+    EventInfo info = {};
+    uint32_t numEvents = 0;
+
+    // We are now on image 0 1 and an event will be triggered
+    ctrl.performRebootFileHandling(false);
+    eventWasCalled(info, numEvents);
+    CHECK(numEvents == 1);
+    CHECK(info.event == CoreController::REBOOT_MECHANISM_TRIGGERED);
+    CHECK(static_cast<xsc::Chip>((info.p1 >> 16) & 0xFFFF) == xsc::CHIP_0);
+    CHECK(static_cast<xsc::Copy>(info.p1 & 0xFFFF) == xsc::COPY_0);
+    CHECK(((info.p2 >> 24) & 0xFF) == 3);
+    CHECK(((info.p2 >> 16) & 0xFF) == 1);
+    CHECK(((info.p2 >> 8) & 0xFF) == 0);
+    CHECK((info.p2 & 0xFF) == 0);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 3);
+    REQUIRE(rf.img01Cnt == 1);
+    REQUIRE(rf.img10Cnt == 0);
+    REQUIRE(rf.img11Cnt == 0);
+    // Flag was cleared when event was thrown
+    REQUIRE(rf.bootFlag == false);
+    REQUIRE(rf.lastChip == xsc::CHIP_0);
+    REQUIRE(rf.lastCopy == xsc::COPY_1);
+    ctrl.performRebootFileHandling(false);
+    ctrl.performRebootFileHandling(false);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 3);
+    REQUIRE(rf.img01Cnt == 3);
+    REQUIRE(rf.img10Cnt == 0);
+    REQUIRE(rf.img11Cnt == 0);
+
+    // We are now on image 1 0 and an event will be triggered
+    ctrl.performRebootFileHandling(false);
+    eventWasCalled(info, numEvents);
+    CHECK(numEvents == 1);
+    CHECK(info.event == CoreController::REBOOT_MECHANISM_TRIGGERED);
+    CHECK(static_cast<xsc::Chip>((info.p1 >> 16) & 0xFFFF) == xsc::CHIP_0);
+    CHECK(static_cast<xsc::Copy>(info.p1 & 0xFFFF) == xsc::COPY_1);
+    CHECK(((info.p2 >> 24) & 0xFF) == 3);
+    CHECK(((info.p2 >> 16) & 0xFF) == 3);
+    CHECK(((info.p2 >> 8) & 0xFF) == 1);
+    CHECK((info.p2 & 0xFF) == 0);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 3);
+    REQUIRE(rf.img01Cnt == 3);
+    REQUIRE(rf.img10Cnt == 1);
+    REQUIRE(rf.img11Cnt == 0);
+    ctrl.performRebootFileHandling(false);
+    ctrl.performRebootFileHandling(false);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 3);
+    REQUIRE(rf.img01Cnt == 3);
+    REQUIRE(rf.img10Cnt == 3);
+    REQUIRE(rf.img11Cnt == 0);
+    eventWasCalled(info, numEvents);
+
+    // On image 1 1 now
+    ctrl.performRebootFileHandling(false);
+    eventWasCalled(info, numEvents);
+    CHECK(numEvents == 1);
+    CHECK(info.event == CoreController::REBOOT_MECHANISM_TRIGGERED);
+    CHECK(static_cast<xsc::Chip>((info.p1 >> 16) & 0xFFFF) == xsc::CHIP_1);
+    CHECK(static_cast<xsc::Copy>(info.p1 & 0xFFFF) == xsc::COPY_0);
+    CHECK(((info.p2 >> 24) & 0xFF) == 3);
+    CHECK(((info.p2 >> 16) & 0xFF) == 3);
+    CHECK(((info.p2 >> 8) & 0xFF) == 3);
+    CHECK((info.p2 & 0xFF) == 1);
+
+    ctrl.performRebootFileHandling(false);
+    ctrl.performRebootFileHandling(false);
+    // Now it should fall back to 0 0 because all are invalid
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 3);
+    REQUIRE(rf.img01Cnt == 3);
+    REQUIRE(rf.img10Cnt == 3);
+    REQUIRE(rf.img11Cnt == 3);
+
+    // Should remain on image now
+    ctrl.performRebootFileHandling(false);
+    eventWasCalled(info, numEvents);
+    CHECK(numEvents == 1);
+    CHECK(info.event == CoreController::REBOOT_MECHANISM_TRIGGERED);
+    CHECK(static_cast<xsc::Chip>((info.p1 >> 16) & 0xFFFF) == xsc::CHIP_1);
+    CHECK(static_cast<xsc::Copy>(info.p1 & 0xFFFF) == xsc::COPY_1);
+    CHECK(((info.p2 >> 24) & 0xFF) == 4);
+    CHECK(((info.p2 >> 16) & 0xFF) == 3);
+    CHECK(((info.p2 >> 8) & 0xFF) == 3);
+    CHECK((info.p2 & 0xFF) == 3);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.img00Cnt == 4);
+    REQUIRE(rf.img01Cnt == 3);
+    REQUIRE(rf.img10Cnt == 3);
+    REQUIRE(rf.img11Cnt == 3);
+
+    // Reset a specific reboot counter
+    cmdData[0] = 0;
+    cmdData[1] = 1;
+    ctrl.executeAction(CoreController::RESET_REBOOT_COUNTERS, 0, cmdData.data(), 2);
+    // Reboot to 0 0 again
+    ctrl.performRebootFileHandling(false);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 5);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 3);
+    REQUIRE(rf.img11Cnt == 3);
+    CHECK(CoreController::CURRENT_CHIP == xsc::CHIP_0);
+    CHECK(CoreController::CURRENT_COPY == xsc::COPY_1);
+    ctrl.executeAction(CoreController::RESET_REBOOT_COUNTERS, 0, nullptr, 0);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 0);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 0);
+    REQUIRE(rf.img11Cnt == 0);
+    uint8_t enable = 0;
+    ctrl.executeAction(CoreController::SWITCH_REBOOT_FILE_HANDLING, 0, &enable, 1);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 0);
+    REQUIRE(rf.img00Cnt == 0);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 0);
+    REQUIRE(rf.img11Cnt == 0);
+
+    // Reboot to 1 0 explicitely
+    CoreController::setCurrentBootCopy(xsc::CHIP_1, xsc::COPY_0);
+    // Reboot three times and verify that no reboot is performed
+    ctrl.performRebootFileHandling(false);
+    ctrl.performRebootFileHandling(false);
+    ctrl.performRebootFileHandling(false);
+    ctrl.performRebootFileHandling(false);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 0);
+    REQUIRE(rf.img00Cnt == 0);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 4);
+    REQUIRE(rf.img11Cnt == 0);
+    // Now enable the functionality again and verify it reboots to 1 1
+    enable = 1;
+    ctrl.executeAction(CoreController::SWITCH_REBOOT_FILE_HANDLING, 0, &enable, 1);
+    ctrl.performRebootFileHandling(false);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 0);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 5);
+    REQUIRE(rf.img11Cnt == 0);
+    ctrl.performRebootFileHandling(false);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 0);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 5);
+    REQUIRE(rf.img11Cnt == 1);
+    ctrl.performRebootFileHandling(false);
+    ctrl.performRebootFileHandling(false);
+    // Should be on 0 0 now
+    CHECK(CoreController::CURRENT_CHIP == xsc::CHIP_0);
+    CHECK(CoreController::CURRENT_COPY == xsc::COPY_0);
+    ctrl.performRebootFileHandling(false);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 1);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 5);
+    REQUIRE(rf.img11Cnt == 3);
+
+    // Now reset all reboot counters manually
+    cmdData[0] = 0;
+    cmdData[1] = 0;
+    ctrl.executeAction(CoreController::RESET_REBOOT_COUNTERS, 0, cmdData.data(), 2);
+    cmdData[0] = 1;
+    cmdData[1] = 0;
+    ctrl.executeAction(CoreController::RESET_REBOOT_COUNTERS, 0, cmdData.data(), 2);
+    cmdData[0] = 1;
+    cmdData[1] = 1;
+    ctrl.executeAction(CoreController::RESET_REBOOT_COUNTERS, 0, cmdData.data(), 2);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 0);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 0);
+    REQUIRE(rf.img11Cnt == 0);
+
+    // Reset lock on 0 1
+    cmdData[0] = false;
+    cmdData[1] = 0;
+    cmdData[2] = 1;
+    ctrl.executeAction(CoreController::SWITCH_IMG_LOCK, 0, cmdData.data(), 3);
+    CHECK(CoreController::CURRENT_CHIP == xsc::CHIP_0);
+    CHECK(CoreController::CURRENT_COPY == xsc::COPY_0);
+    ctrl.performRebootFileHandling(false);
+    ctrl.performRebootFileHandling(false);
+    ctrl.performRebootFileHandling(false);
+    // Now should be on 0 1
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    CHECK(CoreController::CURRENT_CHIP == xsc::CHIP_0);
+    CHECK(CoreController::CURRENT_COPY == xsc::COPY_1);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 3);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 0);
+    REQUIRE(rf.img11Cnt == 0);
+    REQUIRE(rf.img00Lock == false);
+    REQUIRE(rf.img01Lock == false);
+    REQUIRE(rf.img10Lock == false);
+    REQUIRE(rf.img11Lock == false);
+    // Now simulate failure in kernel boot or reboot from ProASIC3
+    ctrl.setCurrentBootCopy(xsc::CHIP_0, xsc::COPY_0);
+    ctrl.performRebootFileHandling(false);
+    // Image 0 1 should have been marked as invalid now. Reboot will be triggered
+    // on 1 0 instead of 0 1 because 0 1 is marked as locked
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 4);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 0);
+    REQUIRE(rf.img11Cnt == 0);
+    REQUIRE(rf.img00Lock == false);
+    REQUIRE(rf.img01Lock == true);
+    REQUIRE(rf.img10Lock == false);
+    REQUIRE(rf.img11Lock == false);
+    ctrl.performRebootFileHandling(false);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 4);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 1);
+    REQUIRE(rf.img11Cnt == 0);
+    REQUIRE(rf.img00Lock == false);
+    REQUIRE(rf.img01Lock == true);
+    REQUIRE(rf.img10Lock == false);
+    REQUIRE(rf.img11Lock == false);
+    // Reset lock on 0 1 again
+    cmdData[0] = false;
+    cmdData[1] = 0;
+    cmdData[2] = 1;
+    ctrl.executeAction(CoreController::SWITCH_IMG_LOCK, 0, cmdData.data(), 3);
+    // Lock 1 1 manually
+    // Reset lock on 0 1 again
+    cmdData[0] = true;
+    cmdData[1] = 1;
+    cmdData[2] = 1;
+    ctrl.executeAction(CoreController::SWITCH_IMG_LOCK, 0, cmdData.data(), 3);
+    ctrl.performRebootFileHandling(false);
+    ctrl.performRebootFileHandling(false);
+    // Should be on 0 1 now
+    ctrl.performRebootFileHandling(false);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 4);
+    REQUIRE(rf.img01Cnt == 1);
+    REQUIRE(rf.img10Cnt == 3);
+    REQUIRE(rf.img11Cnt == 0);
+    REQUIRE(rf.img00Lock == false);
+    REQUIRE(rf.img01Lock == false);
+    REQUIRE(rf.img10Lock == false);
+    REQUIRE(rf.img11Lock == true);
+    // Lock everything except 0 0
+    cmdData[0] = true;
+    cmdData[1] = 0;
+    cmdData[2] = 1;
+    ctrl.executeAction(CoreController::SWITCH_IMG_LOCK, 0, cmdData.data(), 3);
+    cmdData[0] = true;
+    cmdData[1] = 1;
+    cmdData[2] = 0;
+    ctrl.executeAction(CoreController::SWITCH_IMG_LOCK, 0, cmdData.data(), 3);
+    ctrl.executeAction(CoreController::RESET_REBOOT_COUNTERS, 0, nullptr, 0);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 0);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 0);
+    REQUIRE(rf.img11Cnt == 0);
+    REQUIRE(rf.img00Lock == false);
+    REQUIRE(rf.img01Lock == true);
+    REQUIRE(rf.img10Lock == true);
+    REQUIRE(rf.img11Lock == true);
+    // Switch to 0 0
+    ctrl.setCurrentBootCopy(xsc::CHIP_0, xsc::COPY_0);
+    ctrl.performRebootFileHandling(false);
+    ctrl.performRebootFileHandling(false);
+    ctrl.performRebootFileHandling(false);
+    // Should still be on 0 0
+    ctrl.performRebootFileHandling(false);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 4);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 0);
+    REQUIRE(rf.img11Cnt == 0);
+    REQUIRE(rf.img00Lock == false);
+    REQUIRE(rf.img01Lock == true);
+    REQUIRE(rf.img10Lock == true);
+    REQUIRE(rf.img11Lock == true);
+    // Unlock 1 0
+    cmdData[0] = false;
+    cmdData[1] = 1;
+    cmdData[2] = 0;
+    ctrl.executeAction(CoreController::SWITCH_IMG_LOCK, 0, cmdData.data(), 3);
+    // Reboots to 1 0 now
+    ctrl.performRebootFileHandling(false);
+    ctrl.parseRebootFile(REBOOT_FILE, rf);
+    REQUIRE(rf.enabled == 1);
+    REQUIRE(rf.img00Cnt == 5);
+    REQUIRE(rf.img01Cnt == 0);
+    REQUIRE(rf.img10Cnt == 0);
+    REQUIRE(rf.img11Cnt == 0);
+    REQUIRE(rf.img00Lock == false);
+    REQUIRE(rf.img01Lock == true);
+    REQUIRE(rf.img10Lock == false);
+    REQUIRE(rf.img11Lock == true);
+    REQUIRE(CoreController::CURRENT_CHIP == xsc::CHIP_1);
+    REQUIRE(CoreController::CURRENT_COPY == xsc::COPY_0);
+  }
+  if (std::filesystem::exists(CONF_PATH)) {
+    std::uintmax_t n = std::filesystem::remove_all(CONF_PATH);
+    CHECK(n == 2);
+  }
+}
+
+void catFileToConsole() {
+  if (CAT_FILE_TO_CONSOLE) {
+    std::ifstream file(REBOOT_FILE);
+    if (file.is_open()) {
+      std::cout << file.rdbuf();
+    }
+  }
+}

unittest/rebootLogic/src/print.c

@@ -0,0 +1,10 @@
+#include <stdbool.h>
+#include <stdio.h>
+
+void printChar(const char* character, bool errStream) {
+  if (errStream) {
+    putc(*character, stderr);
+    return;
+  }
+  putc(*character, stdout);
+}