Merge pull request 'prep v8.0.0' (#895) from prep_v8.0.0 into main

Reviewed-on: #895

CHANGELOG.md

@@ -16,6 +16,162 @@ will consitute of a breaking change warranting a new major release:
 
 # [unreleased]
 
+# [v8.0.0] 2024-05-13
+
+- `eive-tmtc` v7.0.0
+
+## Fixed
+
+- Fixed calculation for target rotation rate during pointing modes.
+- Possible fix for MPSoC file read algorithm.
+
+## Changed
+
+- Reworked MPSoC handler to be compatible to new MPSoC software image and use
+  new device handler base class. This should increase the reliability of the communication
+  significantly.
+- MPSoC device modes IDLE, SNAPSHOT and REPLAY are now modelled using submodes.
+- Commanding a submode the device is already in will not result in a completion failure
+  anymore.
+
+## Added
+
+- Added `VERIFY_BOOT` command for MPSoC.
+- New command for MPSoC to store camera image in chunks.
+
+# [v7.8.1] 2024-04-11
+
+## Fixed
+
+- Reverted fix for wrong order in quaternion multiplication for computation of the error quaternion.
+
+# [v7.8.0] 2024-04-10
+
+## Changed
+
+- Reverted lower OP limit of `PLOC` to -10°C.
+- All pointing laws are now allowed to use the `MEKF` per default.
+- Changed limits in `PWR Controller`.
+- PUS time service: Now dumps the time before and after relative timeshift or setting absolute time
+- The `GPS Controller` does not set itself to `OFF` anymore, if it has not detected a valid fix for
+  some time. Instead it attempts to reset both GNSS devices once.
+- The maximum time to reach a fix is shortened from 30min to 15min.
+- The time the reset pin of the GNSS devices is pulled is prolonged from 5ms to 10s.
+- A `GPS FIX HAS CHANGED` is now only triggered if no fix change has been detected within the past
+  2min. This means, this event might be thrown with a 2min delay. It is instantly thrown, if the mode
+  of the controller is changed. As arguments it now displays the new fix and the numer of fix changes
+  missed.
+- The number of satellites seen and used is reset to 0, in case they are set to invalid.
+- Altitude, latitude and longitude messages are not checked anymore, in case the mode message was
+  already invalid.
+
+## Added
+
+- PUS timeservice relative timeshift.
+
+## Fixed
+
+- Fixed wrong order in quaternion multiplication for computation of the error quaternion.
+- Re-worked some FDIR logic in the FSFW. The former logic prevented events with a severity
+  higher than INFO if the device was in EXTERNAL CONTROL. The new logic will allow to trigger
+  events but still inhibit FDIR reactions if the device is in EXTERNAL CONTROL.
+
+# [v7.7.4] 2024-03-21
+
+## Changed
+
+- Rotational rate limit for the GS target pointing is now seperated from controller limit. It
+  is also reduced to 0.75°/s now.
+
+## Fixed
+
+- Fixed wrong sign in calculation of total current within the `PWR Controller`.
+
+# [v7.7.3] 2024-03-18
+
+- Bumped `eive-fsfw`
+
+## Added
+
+- Added parameter to disable STR input for MEKF.
+
+## Changed
+
+- If a primary heater is set to `EXTERNAL CONTROL` and `ON`, the `TCS Controller` will no
+  try to control the temperature of that object.
+- Set lower OP limit of `PLOC` to -5°C.
+
+## Fixed
+
+- Added prevention of sign jump for target quaternion of GS pointing, which would reduce the
+  performance of the controller.
+- Heaters set to `EXTERNAL CONTROL` no longer can be switched off by the `TCS Controller`, if
+  they violate the maximum burn duration of the controller.
+
+# [v7.7.2] 2024-03-06
+
+## Fixed
+
+- Camera and E-band antenna now point towards the target instead of away from the target for the
+  pointing target mode.
+
+# [v7.7.1] 2024-03-06
+
+- Bumped `eive-tmtc` to v6.1.1
+- Bumped `eive-fsfw`
+
+## Added
+
+- The `CoreController` now sets the leap seconds on initalization. They are stored in a persistent
+  file. If the file does yet not exist, it will be created. The leap seconds can be updated using an
+  action command. This will also update the file.
+
+## Fixed
+
+- Fixed wrong dimension of a matrix within the `MEKF`, which would lead to a seg fault, if the
+  star tracker was available.
+- Fixed case in which control values within the `AcsController` could become NaN.
+
+# [v7.7.0] 2024-02-29
+
+- Bumped `eive-tmtc` to v6.1.0
+- Bumped `eive-fsfw`
+
+## Fixed
+
+- PLOC SUPV sets: Added missing `PoolReadGuard` instantiations when reading boot status report
+  and latchup status report.
+- PLOC SUPV latchup report could not be handled previously.
+- Bugfix in PLOC SUPV latchup report parsing.
+- Bugfix in PLOC MPSoC HK set: Set and variables were not set valid.
+- The `PTG_CTRL_NO_ATTITUDE_INFORMATION` will now actually trigger a fallback into safe mode
+  and is triggered by the `AcsController` now.
+- Fixed a corner case, in which an invalid speed command could be sent to the `RwHandler`.
+- Fixed calculation of desaturation torque for faulty RWs.
+- Fixed bugs within the `MEKF` and simplified the code.
+
+## Changed
+
+- `FusedRotationRate` now only uses rotation rate from QUEST and STR in higher modes
+- QUEST and STR rates are now allowed per default
+- Changed PTG Strat priorities to favor STR before MEKF.
+- Increased message queue depth and maximum number of handled messages per cycle for
+  `PusServiceBase` based classes (especially PUS scheduler).
+- `MathOperations` functions were moved to their appropriate classes within the `eive-fsfw`
+- Changed pointing strategy for target groundstation mode to prevent blinding of the STR. This
+  also limits the rotation for the reference target quaternion to prevent spikes in required
+  rotation rates.
+- Updated QUEST and Sun Vector Params to new values.
+- Removed the satellites's angular momentum from desaturation calculation.
+- Bumped internal `sagittactl` library to v11.11.
+
+## Added
+
+- Updated STR handler to unlock and allow using the secondary firmware slot.
+- STR handling for new BlobStats TM set.
+- Added new action command to update the standard deviations within the `MEKF` from the
+  `AcsParameters`.
+
 # [v7.6.1] 2024-02-05
 
 ## Changed

CMakeLists.txt

@@ -9,9 +9,9 @@
 # ##############################################################################
 cmake_minimum_required(VERSION 3.13)
 
-set(OBSW_VERSION_MAJOR 7)
-set(OBSW_VERSION_MINOR 6)
-set(OBSW_VERSION_REVISION 1)
+set(OBSW_VERSION_MAJOR 8)
+set(OBSW_VERSION_MINOR 0)
+set(OBSW_VERSION_REVISION 0)
 
 # set(CMAKE_VERBOSE TRUE)
 

archive/PlocMpsocHandler.cpp

@@ -2,15 +2,15 @@
 #include <linux/payload/PlocMpsocHandler.h>
 #include <linux/payload/plocSupvDefs.h>
 
-#include <sstream>
-
 #include "OBSWConfig.h"
 #include "fsfw/datapool/PoolReadGuard.h"
 #include "fsfw/globalfunctions/CRC.h"
+#include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/parameters/HasParametersIF.h"
 
 PlocMpsocHandler::PlocMpsocHandler(object_id_t objectId, object_id_t uartComIFid,
-                                   CookieIF* comCookie, PlocMpsocSpecialComHelper* plocMPSoCHelper,
+                                   CookieIF* comCookie,
+                                   PlocMpsocSpecialComHelperLegacy* plocMPSoCHelper,
                                    Gpio uartIsolatorSwitch, object_id_t supervisorHandler)
     : DeviceHandlerBase(objectId, uartComIFid, comCookie),
       hkReport(this),
@@ -54,24 +54,26 @@ ReturnValue_t PlocMpsocHandler::initialize() {
     return result;
   }
   result = manager->subscribeToEvent(
-      eventQueue->getId(), event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_WRITE_FAILED));
+      eventQueue->getId(),
+      event::getEventId(PlocMpsocSpecialComHelperLegacy::MPSOC_FLASH_WRITE_FAILED));
   if (result != returnvalue::OK) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
   result = manager->subscribeToEvent(
       eventQueue->getId(),
-      event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_WRITE_SUCCESSFUL));
+      event::getEventId(PlocMpsocSpecialComHelperLegacy::MPSOC_FLASH_WRITE_SUCCESSFUL));
   if (result != returnvalue::OK) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
   result = manager->subscribeToEvent(
       eventQueue->getId(),
-      event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_READ_SUCCESSFUL));
+      event::getEventId(PlocMpsocSpecialComHelperLegacy::MPSOC_FLASH_READ_SUCCESSFUL));
   if (result != returnvalue::OK) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
   result = manager->subscribeToEvent(
-      eventQueue->getId(), event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_READ_FAILED));
+      eventQueue->getId(),
+      event::getEventId(PlocMpsocSpecialComHelperLegacy::MPSOC_FLASH_READ_FAILED));
   if (result != returnvalue::OK) {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
@@ -139,7 +141,7 @@ ReturnValue_t PlocMpsocHandler::executeAction(ActionId_t actionId, MessageQueueI
   }
 
   if (specialComHelperExecuting) {
-    return MPSoCReturnValuesIF::MPSOC_HELPER_EXECUTING;
+    return mpsoc::MPSOC_HELPER_EXECUTING;
   }
 
   switch (actionId) {
@@ -408,7 +410,7 @@ ReturnValue_t PlocMpsocHandler::scanForReply(const uint8_t* start, size_t remain
       sif::debug << "PlocMPSoCHandler::scanForReply: Reply has invalid APID 0x" << std::hex
                  << std::setfill('0') << std::setw(2) << apid << std::dec << std::endl;
       *foundLen = remainingSize;
-      return MPSoCReturnValuesIF::INVALID_APID;
+      return mpsoc::INVALID_APID;
     }
   }
 
@@ -445,7 +447,7 @@ ReturnValue_t PlocMpsocHandler::interpretDeviceReply(DeviceCommandId_t id, const
     }
     case (mpsoc::TM_FLASH_DIRECTORY_CONTENT): {
       result = verifyPacket(packet, foundPacketLen);
-      if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
+      if (result == mpsoc::CRC_FAILURE) {
         sif::warning << "PLOC MPSoC: Flash directory content reply invalid CRC" << std::endl;
       }
       /** Send data to commanding queue */
@@ -557,7 +559,7 @@ ReturnValue_t PlocMpsocHandler::prepareTcMemRead(const uint8_t* commandData,
 ReturnValue_t PlocMpsocHandler::prepareTcFlashDelete(const uint8_t* commandData,
                                                      size_t commandDataLen) {
   if (commandDataLen > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
-    return MPSoCReturnValuesIF::NAME_TOO_LONG;
+    return mpsoc::NAME_TOO_LONG;
   }
   ReturnValue_t result = returnvalue::OK;
   mpsoc::TcFlashDelete tcFlashDelete(spParams, sequenceCount);
@@ -718,7 +720,7 @@ ReturnValue_t PlocMpsocHandler::finishTcPrep(mpsoc::TcBase& tcBase) {
 
 ReturnValue_t PlocMpsocHandler::verifyPacket(const uint8_t* start, size_t foundLen) {
   if (CRC::crc16ccitt(start, foundLen) != 0) {
-    return MPSoCReturnValuesIF::CRC_FAILURE;
+    return mpsoc::CRC_FAILURE;
   }
   return returnvalue::OK;
 }
@@ -727,12 +729,12 @@ ReturnValue_t PlocMpsocHandler::handleAckReport(const uint8_t* data) {
   ReturnValue_t result = returnvalue::OK;
 
   result = verifyPacket(data, mpsoc::SIZE_ACK_REPORT);
-  if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
+  if (result == mpsoc::CRC_FAILURE) {
     sif::warning << "PlocMPSoCHandler::handleAckReport: CRC failure" << std::endl;
     nextReplyId = mpsoc::NONE;
     replyRawReplyIfnotWiretapped(data, mpsoc::SIZE_ACK_REPORT);
     triggerEvent(MPSOC_HANDLER_CRC_FAILURE);
-    sendFailureReport(mpsoc::ACK_REPORT, MPSoCReturnValuesIF::CRC_FAILURE);
+    sendFailureReport(mpsoc::ACK_REPORT, mpsoc::CRC_FAILURE);
     disableAllReplies();
     return IGNORE_REPLY_DATA;
   }
@@ -771,7 +773,7 @@ ReturnValue_t PlocMpsocHandler::handleExecutionReport(const uint8_t* data) {
   ReturnValue_t result = returnvalue::OK;
 
   result = verifyPacket(data, mpsoc::SIZE_EXE_REPORT);
-  if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
+  if (result == mpsoc::CRC_FAILURE) {
     sif::warning << "PlocMPSoCHandler::handleExecutionReport: CRC failure" << std::endl;
     nextReplyId = mpsoc::NONE;
     return result;
@@ -792,9 +794,9 @@ ReturnValue_t PlocMpsocHandler::handleExecutionReport(const uint8_t* data) {
       uint16_t status = mpsoc::getStatusFromRawData(data);
       sif::warning << "MPSoC EXE Failure: " << mpsoc::getStatusString(status) << std::endl;
       triggerEvent(EXE_FAILURE, commandId, status);
-      sendFailureReport(mpsoc::EXE_REPORT, MPSoCReturnValuesIF::RECEIVED_EXE_FAILURE);
+      sendFailureReport(mpsoc::EXE_REPORT, mpsoc::RECEIVED_EXE_FAILURE);
       result = IGNORE_REPLY_DATA;
-      cmdDoneHandler(false, MPSoCReturnValuesIF::RECEIVED_EXE_FAILURE);
+      cmdDoneHandler(false, mpsoc::RECEIVED_EXE_FAILURE);
       break;
     }
     default: {
@@ -810,7 +812,7 @@ ReturnValue_t PlocMpsocHandler::handleExecutionReport(const uint8_t* data) {
 ReturnValue_t PlocMpsocHandler::handleMemoryReadReport(const uint8_t* data) {
   ReturnValue_t result = returnvalue::OK;
   result = verifyPacket(data, tmMemReadReport.rememberRequestedSize);
-  if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
+  if (result == mpsoc::CRC_FAILURE) {
     sif::warning << "PlocMPSoCHandler::handleMemoryReadReport: Memory read report has invalid crc"
                  << std::endl;
   }
@@ -998,12 +1000,13 @@ ReturnValue_t PlocMpsocHandler::handleGetHkReport(const uint8_t* data) {
   if (result != returnvalue::OK) {
     return result;
   }
+  hkReport.setValidity(true, true);
   return returnvalue::OK;
 }
 
 ReturnValue_t PlocMpsocHandler::handleCamCmdRpt(const uint8_t* data) {
   ReturnValue_t result = verifyPacket(data, foundPacketLen);
-  if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
+  if (result == mpsoc::CRC_FAILURE) {
     sif::warning << "PlocMPSoCHandler::handleCamCmdRpt: CRC failure" << std::endl;
   }
   SpacePacketReader packetReader(data, foundPacketLen);

archive/PlocMpsocHandler.h

@@ -1,23 +1,19 @@
 #ifndef BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_
 #define BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_
 
-#include <linux/payload/PlocMpsocSpecialComHelper.h>
-#include <linux/payload/mpsocRetvals.h>
+#include <linux/payload/PlocMpsocSpecialComHelperLegacy.h>
 #include <linux/payload/plocMpsocHelpers.h>
 #include <linux/payload/plocSupvDefs.h>
 #include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
 
-#include <string>
-
 #include "fsfw/action/CommandActionHelper.h"
 #include "fsfw/action/CommandsActionsIF.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
-#include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/tmtcservices/SourceSequenceCounter.h"
 #include "fsfw_hal/linux/gpio/Gpio.h"
 #include "fsfw_hal/linux/serial/SerialComIF.h"
 
-static constexpr bool DEBUG_MPSOC_COMMUNICATION = false;
+static constexpr bool DEBUG_MPSOC_COMMUNICATION = true;
 
 /**
  * @brief	This is the device handler for the MPSoC of the payload computer.
@@ -48,7 +44,7 @@ class PlocMpsocHandler : public DeviceHandlerBase, public CommandsActionsIF {
    * @param supervisorHandler   Object ID of the supervisor handler
    */
   PlocMpsocHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie,
-                   PlocMpsocSpecialComHelper* plocMPSoCHelper, Gpio uartIsolatorSwitch,
+                   PlocMpsocSpecialComHelperLegacy* plocMPSoCHelper, Gpio uartIsolatorSwitch,
                    object_id_t supervisorHandler);
   virtual ~PlocMpsocHandler();
   virtual ReturnValue_t initialize() override;
@@ -171,7 +167,7 @@ class PlocMpsocHandler : public DeviceHandlerBase, public CommandsActionsIF {
 
   SerialComIF* uartComIf = nullptr;
 
-  PlocMpsocSpecialComHelper* specialComHelper = nullptr;
+  PlocMpsocSpecialComHelperLegacy* specialComHelper = nullptr;
   Gpio uartIsolatorSwitch;
   object_id_t supervisorHandler = 0;
   CommandActionHelper commandActionHelper;
@@ -186,7 +182,7 @@ class PlocMpsocHandler : public DeviceHandlerBase, public CommandsActionsIF {
   };
 
   TmMemReadReport tmMemReadReport;
-  Countdown cmdCountdown = Countdown(10000);
+  Countdown cmdCountdown = Countdown(15000);
 
   struct TelemetryBuffer {
     uint16_t length = 0;

archive/PlocMpsocSpecialComHelperLegacy.cpp

@@ -0,0 +1,545 @@
+#include <fsfw/globalfunctions/arrayprinter.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <linux/payload/PlocMpsocSpecialComHelperLegacy.h>
+#include <unistd.h>
+
+#include <filesystem>
+#include <fstream>
+
+#ifdef XIPHOS_Q7S
+#include "bsp_q7s/fs/FilesystemHelper.h"
+#endif
+
+#include "mission/utility/Timestamp.h"
+
+using namespace ploc;
+
+PlocMpsocSpecialComHelperLegacy::PlocMpsocSpecialComHelperLegacy(object_id_t objectId)
+    : SystemObject(objectId) {
+  spParams.buf = commandBuffer;
+  spParams.maxSize = sizeof(commandBuffer);
+}
+
+PlocMpsocSpecialComHelperLegacy::~PlocMpsocSpecialComHelperLegacy() {}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::initialize() {
+#ifdef XIPHOS_Q7S
+  sdcMan = SdCardManager::instance();
+  if (sdcMan == nullptr) {
+    sif::warning << "PlocMPSoCHelper::initialize: Invalid SD Card Manager" << std::endl;
+    return returnvalue::FAILED;
+  }
+#endif
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::performOperation(uint8_t operationCode) {
+  ReturnValue_t result = returnvalue::OK;
+  semaphore.acquire();
+  while (true) {
+#if OBSW_THREAD_TRACING == 1
+    trace::threadTrace(opCounter, "PLOC MPSOC Helper");
+#endif
+    switch (internalState) {
+      case InternalState::IDLE: {
+        semaphore.acquire();
+        break;
+      }
+      case InternalState::FLASH_WRITE: {
+        result = performFlashWrite();
+        if (result == returnvalue::OK) {
+          triggerEvent(MPSOC_FLASH_WRITE_SUCCESSFUL, sequenceCount->get());
+        } else {
+          triggerEvent(MPSOC_FLASH_WRITE_FAILED, sequenceCount->get());
+        }
+        internalState = InternalState::IDLE;
+        break;
+      }
+      case InternalState::FLASH_READ: {
+        result = performFlashRead();
+        if (result == returnvalue::OK) {
+          triggerEvent(MPSOC_FLASH_READ_SUCCESSFUL, sequenceCount->get());
+        } else {
+          triggerEvent(MPSOC_FLASH_READ_FAILED, sequenceCount->get());
+        }
+        internalState = InternalState::IDLE;
+        break;
+      }
+      default:
+        sif::debug << "PlocMPSoCHelper::performOperation: Invalid state" << std::endl;
+        break;
+    }
+  }
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::setComIF(
+    DeviceCommunicationIF* communicationInterface_) {
+  uartComIF = dynamic_cast<SerialComIF*>(communicationInterface_);
+  if (uartComIF == nullptr) {
+    sif::warning << "PlocMPSoCHelper::initialize: Invalid uart com if" << std::endl;
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}
+
+void PlocMpsocSpecialComHelperLegacy::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; }
+
+void PlocMpsocSpecialComHelperLegacy::setSequenceCount(SourceSequenceCounter* sequenceCount_) {
+  sequenceCount = sequenceCount_;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::startFlashWrite(std::string obcFile,
+                                                               std::string mpsocFile) {
+  if (internalState != InternalState::IDLE) {
+    return returnvalue::FAILED;
+  }
+  ReturnValue_t result = startFlashReadOrWriteBase(std::move(obcFile), std::move(mpsocFile));
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  internalState = InternalState::FLASH_WRITE;
+  return semaphore.release();
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::startFlashRead(std::string obcFile,
+                                                              std::string mpsocFile,
+                                                              size_t readFileSize) {
+  if (internalState != InternalState::IDLE) {
+    return returnvalue::FAILED;
+  }
+  ReturnValue_t result = startFlashReadOrWriteBase(std::move(obcFile), std::move(mpsocFile));
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  flashReadAndWrite.totalReadSize = readFileSize;
+  internalState = InternalState::FLASH_READ;
+  return semaphore.release();
+}
+
+void PlocMpsocSpecialComHelperLegacy::resetHelper() {
+  spParams.buf = commandBuffer;
+  terminate = false;
+  uartComIF->flushUartRxBuffer(comCookie);
+}
+
+void PlocMpsocSpecialComHelperLegacy::stopProcess() { terminate = true; }
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::performFlashWrite() {
+  ReturnValue_t result = returnvalue::OK;
+  std::ifstream file(flashReadAndWrite.obcFile, std::ifstream::binary);
+  if (file.bad()) {
+    return returnvalue::FAILED;
+  }
+  result = flashfopen(mpsoc::FileAccessModes::WRITE | mpsoc::FileAccessModes::OPEN_ALWAYS);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  // Set position of next character to end of file input stream
+  file.seekg(0, file.end);
+  // tellg returns position of character in input stream
+  size_t remainingSize = file.tellg();
+  size_t dataLength = 0;
+  size_t bytesRead = 0;
+  while (remainingSize > 0) {
+    if (terminate) {
+      return returnvalue::OK;
+    }
+    // The minus 4 is necessary for unknown reasons. Maybe some bug in the ILH software?
+    if (remainingSize > mpsoc::MAX_FLASH_WRITE_DATA_SIZE - 4) {
+      dataLength = mpsoc::MAX_FLASH_WRITE_DATA_SIZE - 4;
+    } else {
+      dataLength = remainingSize;
+    }
+    if (file.bad() or not file.is_open()) {
+      return FILE_WRITE_ERROR;
+    }
+    file.seekg(bytesRead, file.beg);
+    file.read(reinterpret_cast<char*>(fileBuf.data()), dataLength);
+    bytesRead += dataLength;
+    remainingSize -= dataLength;
+    mpsoc::TcFlashWrite tc(spParams, *sequenceCount);
+    result = tc.setPayload(fileBuf.data(), dataLength);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = tc.finishPacket();
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    (*sequenceCount)++;
+    result = handlePacketTransmissionNoReply(tc);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+  }
+  result = flashfclose();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return result;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::performFlashRead() {
+  std::error_code e;
+  std::ofstream ofile(flashReadAndWrite.obcFile, std::ios::trunc | std::ios::binary);
+  if (ofile.bad()) {
+    return returnvalue::FAILED;
+  }
+  ReturnValue_t result = flashfopen(mpsoc::FileAccessModes::READ);
+  if (result != returnvalue::OK) {
+    std::filesystem::remove(flashReadAndWrite.obcFile, e);
+    return result;
+  }
+  size_t readSoFar = 0;
+  size_t nextReadSize = mpsoc::MAX_FLASH_READ_DATA_SIZE;
+  while (readSoFar < flashReadAndWrite.totalReadSize) {
+    if (terminate) {
+      std::filesystem::remove(flashReadAndWrite.obcFile, e);
+      return returnvalue::OK;
+    }
+    nextReadSize = mpsoc::MAX_FLASH_READ_DATA_SIZE;
+    if (flashReadAndWrite.totalReadSize - readSoFar < mpsoc::MAX_FLASH_READ_DATA_SIZE) {
+      nextReadSize = flashReadAndWrite.totalReadSize - readSoFar;
+    }
+    if (ofile.bad() or not ofile.is_open()) {
+      std::filesystem::remove(flashReadAndWrite.obcFile, e);
+      return FILE_READ_ERROR;
+    }
+    mpsoc::TcFlashRead flashReadRequest(spParams, *sequenceCount);
+    result = flashReadRequest.setPayload(nextReadSize);
+    if (result != returnvalue::OK) {
+      std::filesystem::remove(flashReadAndWrite.obcFile, e);
+      return result;
+    }
+    result = flashReadRequest.finishPacket();
+    if (result != returnvalue::OK) {
+      std::filesystem::remove(flashReadAndWrite.obcFile, e);
+      return result;
+    }
+    (*sequenceCount)++;
+    result = handlePacketTransmissionFlashRead(flashReadRequest, ofile, nextReadSize);
+    if (result != returnvalue::OK) {
+      std::filesystem::remove(flashReadAndWrite.obcFile, e);
+      return result;
+    }
+    readSoFar += nextReadSize;
+  }
+  result = flashfclose();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return result;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::flashfopen(uint8_t mode) {
+  spParams.buf = commandBuffer;
+  mpsoc::FlashFopen flashFopen(spParams, *sequenceCount);
+  ReturnValue_t result = flashFopen.setPayload(flashReadAndWrite.mpsocFile, mode);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = flashFopen.finishPacket();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  (*sequenceCount)++;
+  result = handlePacketTransmissionNoReply(flashFopen);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::flashfclose() {
+  spParams.buf = commandBuffer;
+  mpsoc::FlashFclose flashFclose(spParams, *sequenceCount);
+  ReturnValue_t result = flashFclose.finishPacket();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  (*sequenceCount)++;
+  result = handlePacketTransmissionNoReply(flashFclose);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return result;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::handlePacketTransmissionFlashRead(
+    mpsoc::TcFlashRead& tc, std::ofstream& ofile, size_t expectedReadLen) {
+  ReturnValue_t result = sendCommand(tc);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = handleAck();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = handleTmReception();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  // We have the nominal case where the flash read report appears first, or the case where we
+  // get an EXE failure immediately.
+  if (spReader.getApid() == mpsoc::apid::TM_FLASH_READ_REPORT) {
+    result = handleFlashReadReply(ofile, expectedReadLen);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    return handleExe();
+  } else if (spReader.getApid() == mpsoc::apid::EXE_FAILURE) {
+    handleExeFailure();
+  } else {
+    triggerEvent(MPSOC_EXE_INVALID_APID, spReader.getApid(), static_cast<uint32_t>(internalState));
+    sif::warning << "PLOC MPSoC: Expected execution report "
+                 << "but received space packet with apid " << std::hex << spReader.getApid()
+                 << std::endl;
+  }
+  return returnvalue::FAILED;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::handlePacketTransmissionNoReply(ploc::SpTcBase& tc) {
+  ReturnValue_t result = sendCommand(tc);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = handleAck();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  return handleExe();
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::sendCommand(ploc::SpTcBase& tc) {
+  ReturnValue_t result = returnvalue::OK;
+  result = uartComIF->sendMessage(comCookie, tc.getFullPacket(), tc.getFullPacketLen());
+  if (result != returnvalue::OK) {
+    sif::warning << "PlocMPSoCHelper::sendCommand: Failed to send command" << std::endl;
+    triggerEvent(MPSOC_SENDING_COMMAND_FAILED, result, static_cast<uint32_t>(internalState));
+    return result;
+  }
+  return result;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::handleAck() {
+  ReturnValue_t result = returnvalue::OK;
+  result = handleTmReception();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = checkReceivedTm();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  uint16_t apid = spReader.getApid();
+  if (apid != mpsoc::apid::ACK_SUCCESS) {
+    handleAckApidFailure(spReader);
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}
+
+void PlocMpsocSpecialComHelperLegacy::handleAckApidFailure(const ploc::SpTmReader& reader) {
+  uint16_t apid = reader.getApid();
+  if (apid == mpsoc::apid::ACK_FAILURE) {
+    uint16_t status = mpsoc::getStatusFromRawData(reader.getFullData());
+    sif::warning << "PLOC MPSoC ACK Failure: " << mpsoc::getStatusString(status) << std::endl;
+    triggerEvent(MPSOC_ACK_FAILURE_REPORT, static_cast<uint32_t>(internalState), status);
+  } else {
+    triggerEvent(MPSOC_ACK_INVALID_APID, apid, static_cast<uint32_t>(internalState));
+    sif::warning << "PlocMPSoCHelper::handleAckApidFailure: Expected acknowledgement report "
+                 << "but received space packet with apid " << std::hex << apid << std::endl;
+  }
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::handleExe() {
+  ReturnValue_t result = returnvalue::OK;
+
+  result = handleTmReception();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = checkReceivedTm();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  uint16_t apid = spReader.getApid();
+  if (apid == mpsoc::apid::EXE_FAILURE) {
+    handleExeFailure();
+    return returnvalue::FAILED;
+  } else if (apid != mpsoc::apid::EXE_SUCCESS) {
+    triggerEvent(MPSOC_EXE_INVALID_APID, apid, static_cast<uint32_t>(internalState));
+    sif::warning << "PLOC MPSoC: Expected execution report "
+                 << "but received space packet with apid " << std::hex << apid << std::endl;
+  }
+  return returnvalue::OK;
+}
+
+void PlocMpsocSpecialComHelperLegacy::handleExeFailure() {
+  uint16_t status = mpsoc::getStatusFromRawData(spReader.getFullData());
+  sif::warning << "PLOC MPSoC EXE Failure: " << mpsoc::getStatusString(status) << std::endl;
+  triggerEvent(MPSOC_EXE_FAILURE_REPORT, static_cast<uint32_t>(internalState));
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::handleTmReception() {
+  ReturnValue_t result = returnvalue::OK;
+  tmCountdown.resetTimer();
+  size_t readBytes = 0;
+  size_t currentBytes = 0;
+  uint32_t usleepDelay = 5;
+  size_t fullPacketLen = 0;
+  while (true) {
+    if (tmCountdown.hasTimedOut()) {
+      triggerEvent(MPSOC_READ_TIMEOUT, tmCountdown.getTimeoutMs());
+      return returnvalue::FAILED;
+    }
+    result = receive(tmBuf.data() + readBytes, 6, &currentBytes);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    spReader.setReadOnlyData(tmBuf.data(), tmBuf.size());
+    fullPacketLen = spReader.getFullPacketLen();
+    readBytes += currentBytes;
+    if (readBytes == 6) {
+      break;
+    }
+    usleep(usleepDelay);
+    if (usleepDelay < 200000) {
+      usleepDelay *= 4;
+    }
+  }
+  while (true) {
+    if (tmCountdown.hasTimedOut()) {
+      triggerEvent(MPSOC_READ_TIMEOUT, tmCountdown.getTimeoutMs());
+      return returnvalue::FAILED;
+    }
+    result = receive(tmBuf.data() + readBytes, fullPacketLen - readBytes, &currentBytes);
+    readBytes += currentBytes;
+    if (fullPacketLen == readBytes) {
+      break;
+    }
+    usleep(usleepDelay);
+    if (usleepDelay < 200000) {
+      usleepDelay *= 4;
+    }
+  }
+  // arrayprinter::print(tmBuf.data(), readBytes);
+  return result;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::handleFlashReadReply(std::ofstream& ofile,
+                                                                    size_t expectedReadLen) {
+  ReturnValue_t result = checkReceivedTm();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  uint16_t apid = spReader.getApid();
+  if (apid != mpsoc::apid::TM_FLASH_READ_REPORT) {
+    triggerEvent(MPSOC_FLASH_READ_PACKET_ERROR, FlashReadErrorType::FLASH_READ_APID_ERROR);
+    sif::warning << "PLOC MPSoC Flash Read: Unexpected APID" << std::endl;
+    return result;
+  }
+  const uint8_t* packetData = spReader.getPacketData();
+  size_t deserDummy = spReader.getPacketDataLen() - mpsoc::CRC_SIZE;
+  uint32_t receivedReadLen = 0;
+  // I think this is buggy, weird stuff in the short name field.
+  //  std::string receivedShortName = std::string(reinterpret_cast<const char*>(packetData), 12);
+  //  if (receivedShortName != flashReadAndWrite.mpsocFile.substr(0, 11)) {
+  //    sif::warning << "PLOC MPSoC Flash Read: Missmatch between request file name and "
+  //                    "received file name"
+  //                 << std::endl;
+  //    triggerEvent(MPSOC_FLASH_READ_PACKET_ERROR, FlashReadErrorType::FLASH_READ_FILENAME_ERROR);
+  //    return returnvalue::FAILED;
+  //  }
+  packetData += 12;
+  result = SerializeAdapter::deSerialize(&receivedReadLen, &packetData, &deserDummy,
+                                         SerializeIF::Endianness::NETWORK);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  if (receivedReadLen != expectedReadLen) {
+    sif::warning << "PLOC MPSoC Flash Read: Missmatch between request read length and "
+                    "received read length"
+                 << std::endl;
+    triggerEvent(MPSOC_FLASH_READ_PACKET_ERROR, FlashReadErrorType::FLASH_READ_READLEN_ERROR);
+    return returnvalue::FAILED;
+  }
+  ofile.write(reinterpret_cast<const char*>(packetData), receivedReadLen);
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::fileCheck(std::string obcFile) {
+#ifdef XIPHOS_Q7S
+  ReturnValue_t result = FilesystemHelper::checkPath(obcFile);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+#elif defined(TE0720_1CFA)
+  if (not std::filesystem::exists(obcFile)) {
+    sif::warning << "PlocMPSoCHelper::startFlashWrite: File " << obcFile << "does not exist"
+                 << std::endl;
+    return returnvalue::FAILED;
+  }
+#endif
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::startFlashReadOrWriteBase(std::string obcFile,
+                                                                         std::string mpsocFile) {
+  ReturnValue_t result = fileCheck(obcFile);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+
+  flashReadAndWrite.obcFile = std::move(obcFile);
+  flashReadAndWrite.mpsocFile = std::move(mpsocFile);
+  resetHelper();
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::checkReceivedTm() {
+  ReturnValue_t result = spReader.checkSize();
+  if (result != returnvalue::OK) {
+    sif::error << "PLOC MPSoC: Size check on received TM failed" << std::endl;
+    triggerEvent(MPSOC_TM_SIZE_ERROR);
+    return result;
+  }
+  result = spReader.checkCrc();
+  if (result != returnvalue::OK) {
+    sif::warning << "PLOC MPSoC: CRC check failed" << std::endl;
+    triggerEvent(MPSOC_TM_CRC_MISSMATCH, *sequenceCount);
+    return result;
+  }
+  uint16_t recvSeqCnt = spReader.getSequenceCount();
+  if (recvSeqCnt != *sequenceCount) {
+    triggerEvent(MPSOC_HELPER_SEQ_CNT_MISMATCH, *sequenceCount, recvSeqCnt);
+    *sequenceCount = recvSeqCnt;
+  }
+  // This sequence count ping pong does not make any sense but it is how the MPSoC expects it.
+  (*sequenceCount)++;
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocSpecialComHelperLegacy::receive(uint8_t* data, size_t requestBytes,
+                                                       size_t* readBytes) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t* buffer = nullptr;
+  result = uartComIF->requestReceiveMessage(comCookie, requestBytes);
+  if (result != returnvalue::OK) {
+    sif::warning << "PlocMPSoCHelper::receive: Failed to request reply" << std::endl;
+    triggerEvent(MPSOC_HELPER_REQUESTING_REPLY_FAILED, result,
+                 static_cast<uint32_t>(static_cast<uint32_t>(internalState)));
+    return returnvalue::FAILED;
+  }
+  result = uartComIF->readReceivedMessage(comCookie, &buffer, readBytes);
+  if (result != returnvalue::OK) {
+    sif::warning << "PlocMPSoCHelper::receive: Failed to read received message" << std::endl;
+    triggerEvent(MPSOC_HELPER_READING_REPLY_FAILED, result, static_cast<uint32_t>(internalState));
+    return returnvalue::FAILED;
+  }
+  if (*readBytes > 0) {
+    std::memcpy(data, buffer, *readBytes);
+  }
+  return result;
+}

archive/PlocMpsocSpecialComHelperLegacy.h

@@ -0,0 +1,200 @@
+#ifndef BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_
+#define BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_
+
+#include <linux/payload/plocMpsocHelpers.h>
+#include <mission/utility/trace.h>
+
+#include <string>
+
+#include "OBSWConfig.h"
+#include "fsfw/devicehandlers/CookieIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/osal/linux/BinarySemaphore.h"
+#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+#include "fsfw/tmtcservices/SourceSequenceCounter.h"
+#include "fsfw_hal/linux/serial/SerialComIF.h"
+#ifdef XIPHOS_Q7S
+#include "bsp_q7s/fs/SdCardManager.h"
+#endif
+
+/**
+ * @brief   Helper class for MPSoC of PLOC intended to accelerate large data transfers between
+ *          MPSoC and OBC.
+ * @author  J. Meier
+ */
+class PlocMpsocSpecialComHelperLegacy : public SystemObject, public ExecutableObjectIF {
+ public:
+  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HELPER;
+
+  //! [EXPORT] : [COMMENT] Flash write fails
+  static const Event MPSOC_FLASH_WRITE_FAILED = MAKE_EVENT(0, severity::LOW);
+  //! [EXPORT] : [COMMENT] Flash write successful
+  static const Event MPSOC_FLASH_WRITE_SUCCESSFUL = MAKE_EVENT(1, severity::INFO);
+  //! [EXPORT] : [COMMENT] Communication interface returned failure when trying to send the command
+  //! to the MPSoC
+  //! P1: Return value returned by the communication interface sendMessage function
+  //! P2: Internal state of MPSoC helper
+  static const Event MPSOC_SENDING_COMMAND_FAILED = MAKE_EVENT(2, severity::LOW);
+  //! [EXPORT] : [COMMENT] Request receive message of communication interface failed
+  //! P1: Return value returned by the communication interface requestReceiveMessage function
+  //! P2: Internal state of MPSoC helper
+  static const Event MPSOC_HELPER_REQUESTING_REPLY_FAILED = MAKE_EVENT(3, severity::LOW);
+  //! [EXPORT] : [COMMENT] Reading receive message of communication interface failed
+  //! P1: Return value returned by the communication interface readingReceivedMessage function
+  //! P2: Internal state of MPSoC helper
+  static const Event MPSOC_HELPER_READING_REPLY_FAILED = MAKE_EVENT(4, severity::LOW);
+  //! [EXPORT] : [COMMENT] Did not receive acknowledgment report
+  //! P1: Number of bytes missing
+  //! P2: Internal state of MPSoC helper
+  static const Event MPSOC_MISSING_ACK = MAKE_EVENT(5, severity::LOW);
+  //! [EXPORT] : [COMMENT] Did not receive execution report
+  //! P1: Number of bytes missing
+  //! P2: Internal state of MPSoC helper
+  static const Event MPSOC_MISSING_EXE = MAKE_EVENT(6, severity::LOW);
+  //! [EXPORT] : [COMMENT] Received acknowledgment failure report
+  //! P1: Internal state of MPSoC
+  static const Event MPSOC_ACK_FAILURE_REPORT = MAKE_EVENT(7, severity::LOW);
+  //! [EXPORT] : [COMMENT] Received execution failure report
+  //! P1: Internal state of MPSoC
+  static const Event MPSOC_EXE_FAILURE_REPORT = MAKE_EVENT(8, severity::LOW);
+  //! [EXPORT] : [COMMENT] Expected acknowledgment report but received space packet with other apid
+  //! P1: Apid of received space packet
+  //! P2: Internal state of MPSoC
+  static const Event MPSOC_ACK_INVALID_APID = MAKE_EVENT(9, severity::LOW);
+  //! [EXPORT] : [COMMENT] Expected execution report but received space packet with other apid
+  //! P1: Apid of received space packet
+  //! P2: Internal state of MPSoC
+  static const Event MPSOC_EXE_INVALID_APID = MAKE_EVENT(10, severity::LOW);
+  //! [EXPORT] : [COMMENT] Received sequence count does not match expected sequence count
+  //! P1: Expected sequence count
+  //! P2: Received sequence count
+  static const Event MPSOC_HELPER_SEQ_CNT_MISMATCH = MAKE_EVENT(11, severity::LOW);
+  static const Event MPSOC_TM_SIZE_ERROR = MAKE_EVENT(12, severity::LOW);
+  static const Event MPSOC_TM_CRC_MISSMATCH = MAKE_EVENT(13, severity::LOW);
+  static const Event MPSOC_FLASH_READ_PACKET_ERROR = MAKE_EVENT(14, severity::LOW);
+  static const Event MPSOC_FLASH_READ_FAILED = MAKE_EVENT(15, severity::LOW);
+  static const Event MPSOC_FLASH_READ_SUCCESSFUL = MAKE_EVENT(16, severity::INFO);
+  static const Event MPSOC_READ_TIMEOUT = MAKE_EVENT(17, severity::LOW);
+
+  enum FlashReadErrorType : uint32_t {
+    FLASH_READ_APID_ERROR = 0,
+    FLASH_READ_FILENAME_ERROR = 1,
+    FLASH_READ_READLEN_ERROR = 2
+  };
+
+  PlocMpsocSpecialComHelperLegacy(object_id_t objectId);
+  virtual ~PlocMpsocSpecialComHelperLegacy();
+
+  ReturnValue_t initialize() override;
+  ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+  ReturnValue_t setComIF(DeviceCommunicationIF* communicationInterface_);
+  void setComCookie(CookieIF* comCookie_);
+
+  /**
+   * @brief   Starts flash write sequence
+   *
+   * @param obcFile   File where to read from the data
+   * @param mpsocFile The file of the MPSoC where should be written to
+   *
+   * @return  returnvalue::OK if successful, otherwise error return value
+   */
+  ReturnValue_t startFlashWrite(std::string obcFile, std::string mpsocFile);
+  /**
+   *
+   * @param obcFile Full target file name on OBC
+   * @param mpsocFile The file on the MPSoC which should be copied ot the OBC
+   * @param readFileSize The size of the file on the MPSoC.
+   * @return
+   */
+  ReturnValue_t startFlashRead(std::string obcFile, std::string mpsocFile, size_t readFileSize);
+
+  /**
+   * @brief   Can be used to interrupt a running data transfer.
+   */
+  void stopProcess();
+
+  /**
+   * @brief   Sets the sequence count object responsible for the sequence count handling
+   */
+  void setSequenceCount(SourceSequenceCounter* sequenceCount_);
+
+ private:
+  static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MPSOC_HELPER;
+
+  //! [EXPORT] : [COMMENT] File error occured for file transfers from OBC to the MPSoC.
+  static const ReturnValue_t FILE_WRITE_ERROR = MAKE_RETURN_CODE(0xA0);
+  //! [EXPORT] : [COMMENT] File error occured for file transfers from MPSoC to OBC.
+  static const ReturnValue_t FILE_READ_ERROR = MAKE_RETURN_CODE(0xA1);
+
+  // Maximum number of times the communication interface retries polling data from the reply
+  // buffer
+  static const int RETRIES = 10000;
+
+  struct FlashInfo {
+    std::string obcFile;
+    std::string mpsocFile;
+  };
+
+  struct FlashRead : public FlashInfo {
+    size_t totalReadSize = 0;
+  };
+
+  struct FlashRead flashReadAndWrite;
+#if OBSW_THREAD_TRACING == 1
+  uint32_t opCounter = 0;
+#endif
+
+  enum class InternalState { IDLE, FLASH_WRITE, FLASH_READ };
+
+  InternalState internalState = InternalState::IDLE;
+
+  BinarySemaphore semaphore;
+#ifdef XIPHOS_Q7S
+  SdCardManager* sdcMan = nullptr;
+#endif
+  uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE];
+  SpacePacketCreator creator;
+  ploc::SpTcParams spParams = ploc::SpTcParams(creator);
+
+  Countdown tmCountdown = Countdown(5000);
+
+  std::array<uint8_t, mpsoc::SP_MAX_DATA_SIZE> fileBuf{};
+  std::array<uint8_t, mpsoc::MAX_REPLY_SIZE> tmBuf{};
+
+  bool terminate = false;
+
+  /**
+   * Communication interface of MPSoC responsible for low level access. Must be set by the
+   * MPSoC Handler.
+   */
+  SerialComIF* uartComIF = nullptr;
+  // Communication cookie. Must be set by the MPSoC Handler
+  CookieIF* comCookie = nullptr;
+  // Sequence count, must be set by Ploc MPSoC Handler
+  SourceSequenceCounter* sequenceCount = nullptr;
+  ploc::SpTmReader spReader;
+
+  void resetHelper();
+  ReturnValue_t performFlashWrite();
+  ReturnValue_t performFlashRead();
+  ReturnValue_t flashfopen(uint8_t accessMode);
+  ReturnValue_t flashfclose();
+  ReturnValue_t handlePacketTransmissionNoReply(ploc::SpTcBase& tc);
+  ReturnValue_t handlePacketTransmissionFlashRead(mpsoc::TcFlashRead& tc, std::ofstream& ofile,
+                                                  size_t expectedReadLen);
+  ReturnValue_t handleFlashReadReply(std::ofstream& ofile, size_t expectedReadLen);
+  ReturnValue_t sendCommand(ploc::SpTcBase& tc);
+  ReturnValue_t receive(uint8_t* data, size_t requestBytes, size_t* readBytes);
+  ReturnValue_t handleAck();
+  ReturnValue_t handleExe();
+  ReturnValue_t startFlashReadOrWriteBase(std::string obcFile, std::string mpsocFile);
+  ReturnValue_t fileCheck(std::string obcFile);
+  void handleAckApidFailure(const ploc::SpTmReader& reader);
+  void handleExeFailure();
+  ReturnValue_t handleTmReception();
+  ReturnValue_t checkReceivedTm();
+};
+
+#endif /* BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_ */

bsp_hosted/OBSWConfig.h.in

@@ -48,6 +48,7 @@
 #define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    1
 #define OBSW_PRINT_MISSED_DEADLINES                 1
 
+#define OBSW_MPSOC_JTAG_BOOT                        0
 #define OBSW_SYRLINKS_SIMULATED                     1
 #define OBSW_ADD_TEST_CODE                          0
 #define OBSW_ADD_TEST_TASK                          0

bsp_hosted/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 319 translations.
+ * @brief    Auto-generated event translation file. Contains 325 translations.
  * @details
- * Generated on: 2024-01-30 09:10:05
+ * Generated on: 2024-05-06 13:47:38
  */
 #include "translateEvents.h"
 
@@ -82,8 +82,11 @@ const char *BIT_LOCK_STRING = "BIT_LOCK";
 const char *BIT_LOCK_LOST_STRING = "BIT_LOCK_LOST";
 const char *FRAME_PROCESSING_FAILED_STRING = "FRAME_PROCESSING_FAILED";
 const char *CLOCK_SET_STRING = "CLOCK_SET";
-const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
+const char *CLOCK_DUMP_LEGACY_STRING = "CLOCK_DUMP_LEGACY";
 const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
+const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
+const char *CLOCK_DUMP_BEFORE_SETTING_TIME_STRING = "CLOCK_DUMP_BEFORE_SETTING_TIME";
+const char *CLOCK_DUMP_AFTER_SETTING_TIME_STRING = "CLOCK_DUMP_AFTER_SETTING_TIME";
 const char *TC_DELETION_FAILED_STRING = "TC_DELETION_FAILED";
 const char *TEST_STRING = "TEST";
 const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
@@ -104,6 +107,7 @@ const char *SAFE_MODE_CONTROLLER_FAILURE_STRING = "SAFE_MODE_CONTROLLER_FAILURE"
 const char *TLE_TOO_OLD_STRING = "TLE_TOO_OLD";
 const char *TLE_FILE_READ_FAILED_STRING = "TLE_FILE_READ_FAILED";
 const char *PTG_RATE_VIOLATION_STRING = "PTG_RATE_VIOLATION";
+const char *DETUMBLE_TRANSITION_FAILED_STRING = "DETUMBLE_TRANSITION_FAILED";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
@@ -138,6 +142,7 @@ const char *MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUEN
 const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
 const char *SUPV_NOT_ON_STRING = "SUPV_NOT_ON";
 const char *SUPV_REPLY_TIMEOUT_STRING = "SUPV_REPLY_TIMEOUT";
+const char *CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE_STRING = "CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@@ -240,6 +245,7 @@ const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903_STRING = "SIDE_SWITCH_TRANS
 const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
 const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
 const char *CANT_GET_FIX_STRING = "CANT_GET_FIX";
+const char *RESET_FAIL_STRING = "RESET_FAIL";
 const char *P60_BOOT_COUNT_STRING = "P60_BOOT_COUNT";
 const char *BATT_MODE_STRING = "BATT_MODE";
 const char *BATT_MODE_CHANGED_STRING = "BATT_MODE_CHANGED";
@@ -482,9 +488,15 @@ const char *translateEvents(Event event) {
     case (8900):
       return CLOCK_SET_STRING;
     case (8901):
-      return CLOCK_DUMP_STRING;
+      return CLOCK_DUMP_LEGACY_STRING;
     case (8902):
       return CLOCK_SET_FAILURE_STRING;
+    case (8903):
+      return CLOCK_DUMP_STRING;
+    case (8904):
+      return CLOCK_DUMP_BEFORE_SETTING_TIME_STRING;
+    case (8905):
+      return CLOCK_DUMP_AFTER_SETTING_TIME_STRING;
     case (9100):
       return TC_DELETION_FAILED_STRING;
     case (9700):
@@ -525,6 +537,8 @@ const char *translateEvents(Event event) {
       return TLE_FILE_READ_FAILED_STRING;
     case (11210):
       return PTG_RATE_VIOLATION_STRING;
+    case (11211):
+      return DETUMBLE_TRANSITION_FAILED_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -593,6 +607,8 @@ const char *translateEvents(Event event) {
       return SUPV_NOT_ON_STRING;
     case (11608):
       return SUPV_REPLY_TIMEOUT_STRING;
+    case (11609):
+      return CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE_STRING;
     case (11701):
       return SELF_TEST_I2C_FAILURE_STRING;
     case (11702):
@@ -797,6 +813,8 @@ const char *translateEvents(Event event) {
       return GPS_FIX_CHANGE_STRING;
     case (13101):
       return CANT_GET_FIX_STRING;
+    case (13102):
+      return RESET_FAIL_STRING;
     case (13200):
       return P60_BOOT_COUNT_STRING;
     case (13201):

bsp_hosted/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 175 translations.
- * Generated on: 2024-01-30 09:10:05
+ * Contains 176 translations.
+ * Generated on: 2024-05-06 13:47:38
  */
 #include "translateObjects.h"
 
@@ -65,6 +65,7 @@ const char *PTME_VC3_CFDP_TM_STRING = "PTME_VC3_CFDP_TM";
 const char *PLOC_MPSOC_HANDLER_STRING = "PLOC_MPSOC_HANDLER";
 const char *PLOC_SUPERVISOR_HANDLER_STRING = "PLOC_SUPERVISOR_HANDLER";
 const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER";
+const char *PLOC_MPSOC_COMMUNICATION_STRING = "PLOC_MPSOC_COMMUNICATION";
 const char *SCEX_STRING = "SCEX";
 const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
 const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
@@ -302,6 +303,8 @@ const char *translateObject(object_id_t object) {
       return PLOC_SUPERVISOR_HANDLER_STRING;
     case 0x44330017:
       return PLOC_SUPERVISOR_HELPER_STRING;
+    case 0x44330018:
+      return PLOC_MPSOC_COMMUNICATION_STRING;
     case 0x44330032:
       return SCEX_STRING;
     case 0x444100A2:

bsp_hosted/objectFactory.cpp

@@ -39,8 +39,6 @@
 #include "devices/gpioIds.h"
 #include "fsfw_hal/linux/gpio/Gpio.h"
 #include "linux/payload/FreshSupvHandler.h"
-#include "linux/payload/PlocMpsocHandler.h"
-#include "linux/payload/PlocMpsocSpecialComHelper.h"
 #include "linux/payload/PlocSupvUartMan.h"
 #include "test/gpio/DummyGpioIF.h"
 #endif
@@ -79,7 +77,10 @@ void ObjectFactory::produce(void* args) {
     switcherList.emplace_back(initVal);
   }
   dummySwitcher->setInitialSwitcherList(switcherList);
+
 #ifdef PLATFORM_UNIX
+  // Obsolete dev handler..
+  /*
   new SerialComIF(objects::UART_COM_IF);
 #if OBSW_ADD_PLOC_MPSOC == 1
   std::string mpscoDev = "";
@@ -90,7 +91,8 @@ void ObjectFactory::produce(void* args) {
   new PlocMpsocHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie,
                        plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, dummyGpioIF),
                        objects::PLOC_SUPERVISOR_HANDLER);
-#endif /* OBSW_ADD_PLOC_MPSOC == 1 */
+#endif // OBSW_ADD_PLOC_MPSOC == 1
+  */
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
   std::string plocSupvString = "/dev/ploc_supv";
   auto supervisorCookie =

bsp_q7s/core/CoreController.cpp

@@ -480,6 +480,16 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
       successRecipient = commandedBy;
       return returnvalue::OK;
     }
+    case (UPDATE_LEAP_SECONDS): {
+      if (size != sizeof(uint16_t)) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      ReturnValue_t result = actionUpdateLeapSeconds(data);
+      if (result != returnvalue::OK) {
+        return result;
+      }
+      return HasActionsIF::EXECUTION_FINISHED;
+    }
     default: {
       return HasActionsIF::INVALID_ACTION_ID;
     }
@@ -1411,6 +1421,9 @@ void CoreController::performMountedSdCardOperations() {
       if (not timeFileInitDone) {
         initClockFromTimeFile();
       }
+      if (not leapSecondsInitDone) {
+        initLeapSeconds();
+      }
       performRebootWatchdogHandling(false);
       performRebootCountersHandling(false);
     }
@@ -2066,14 +2079,78 @@ ReturnValue_t CoreController::backupTimeFileHandler() {
   return returnvalue::OK;
 }
 
+void CoreController::initLeapSeconds() {
+  ReturnValue_t result = initLeapSecondsFromFile();
+  if (result != returnvalue::OK) {
+    Clock::setLeapSeconds(config::LEAP_SECONDS);
+    writeLeapSecondsToFile(config::LEAP_SECONDS);
+  }
+  leapSecondsInitDone = true;
+}
+
+ReturnValue_t CoreController::initLeapSecondsFromFile() {
+  std::string fileName = currMntPrefix + LEAP_SECONDS_FILE;
+  std::error_code e;
+  if (sdcMan->isSdCardUsable(std::nullopt) and std::filesystem::exists(fileName, e)) {
+    std::ifstream leapSecondsFile(fileName);
+    std::string nextWord;
+    std::getline(leapSecondsFile, nextWord);
+    std::istringstream iss(nextWord);
+    iss >> nextWord;
+    if (iss.bad() or nextWord != "LEAP") {
+      return returnvalue::FAILED;
+    }
+    iss >> nextWord;
+    if (iss.bad() or nextWord != "SECONDS:") {
+      return returnvalue::FAILED;
+    }
+    iss >> nextWord;
+    uint16_t leapSeconds = 0;
+    leapSeconds = std::stoi(nextWord.c_str());
+    if (iss.bad()) {
+      return returnvalue::FAILED;
+    }
+    Clock::setLeapSeconds(leapSeconds);
+    return returnvalue::OK;
+  }
+  sif::error
+      << "CoreController::leapSecondsFileHandler: Initalization of leap seconds from file failed"
+      << std::endl;
+  return returnvalue::FAILED;
+};
+
+ReturnValue_t CoreController::writeLeapSecondsToFile(const uint16_t leapSeconds) {
+  std::string fileName = currMntPrefix + LEAP_SECONDS_FILE;
+  if (not sdcMan->isSdCardUsable(std::nullopt)) {
+    return returnvalue::FAILED;
+  }
+  std::ofstream leapSecondsFile(fileName.c_str(), std::ofstream::out | std::ofstream::trunc);
+  if (not leapSecondsFile.good()) {
+    sif::error << "CoreController::leapSecondsFileHandler: Error opening leap seconds file: "
+               << strerror(errno) << std::endl;
+    return returnvalue::FAILED;
+  }
+  leapSecondsFile << "LEAP SECONDS: " << leapSeconds << std::endl;
+  return returnvalue::OK;
+};
+
+ReturnValue_t CoreController::actionUpdateLeapSeconds(const uint8_t *data) {
+  uint16_t leapSeconds = data[1] | (data[0] << 8);
+  ReturnValue_t result = writeLeapSecondsToFile(leapSeconds);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  Clock::setLeapSeconds(leapSeconds);
+  return returnvalue::OK;
+}
+
 ReturnValue_t CoreController::initClockFromTimeFile() {
   using namespace GpsHyperion;
   using namespace std;
   std::string fileName = currMntPrefix + BACKUP_TIME_FILE;
   std::error_code e;
   if (sdcMan->isSdCardUsable(std::nullopt) and std::filesystem::exists(fileName, e) and
-      ((gpsFix == FixMode::UNKNOWN or gpsFix == FixMode::NOT_SEEN) or
-       not utility::timeSanityCheck())) {
+      ((gpsFix == FixMode::NOT_SEEN) or not utility::timeSanityCheck())) {
     ifstream timeFile(fileName);
     string nextWord;
     getline(timeFile, nextWord);

bsp_q7s/core/CoreController.h

@@ -9,7 +9,7 @@
 #include <fsfw/parameters/ReceivesParameterMessagesIF.h>
 #include <fsfw_hal/linux/uio/UioMapper.h>
 #include <libxiphos.h>
-#include <mission/acs/archive/GPSDefinitions.h>
+#include <linux/acs/GPSDefinitions.h>
 #include <mission/utility/trace.h>
 
 #include <atomic>
@@ -150,6 +150,8 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
       std::string(core::LEGACY_REBOOT_WATCHDOG_FILE_NAME);
   const std::string REBOOT_WATCHDOG_FILE =
       "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::REBOOT_WATCHDOG_FILE_NAME);
+  const std::string LEAP_SECONDS_FILE =
+      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::LEAP_SECONDS_FILE_NAME);
   const std::string BACKUP_TIME_FILE =
       "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::TIME_FILE_NAME);
   const std::string REBOOT_COUNTERS_FILE =
@@ -209,7 +211,7 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
   static constexpr MutexIF::TimeoutType TIMEOUT_TYPE = MutexIF::TimeoutType::WAITING;
   static constexpr uint32_t MUTEX_TIMEOUT = 20;
   bool enableHkSet = false;
-  GpsHyperion::FixMode gpsFix = GpsHyperion::FixMode::UNKNOWN;
+  GpsHyperion::FixMode gpsFix = GpsHyperion::FixMode::NOT_SEEN;
 
   // States for SD state machine, which is used in non-blocking mode
   enum class SdStates {
@@ -296,6 +298,7 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
 
   std::string currMntPrefix;
   bool timeFileInitDone = false;
+  bool leapSecondsInitDone = false;
   bool performOneShotSdCardOpsSwitch = false;
   uint8_t shortSdCardCdCounter = 0;
 #if OBSW_THREAD_TRACING == 1
@@ -335,7 +338,11 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
   void performMountedSdCardOperations();
   ReturnValue_t initVersionFile();
 
+  void initLeapSeconds();
+  ReturnValue_t initLeapSecondsFromFile();
   ReturnValue_t initClockFromTimeFile();
+  ReturnValue_t actionUpdateLeapSeconds(const uint8_t* data);
+  ReturnValue_t writeLeapSecondsToFile(const uint16_t leapSeconds);
   ReturnValue_t performSdCardCheck();
   ReturnValue_t backupTimeFileHandler();
   ReturnValue_t initBootCopyFile();

bsp_q7s/objectFactory.cpp

@@ -10,8 +10,9 @@
 #include <linux/acs/RwPollingTask.h>
 #include <linux/acs/StrComHandler.h>
 #include <linux/com/SyrlinksComHandler.h>
+#include <linux/payload/FreshMpsocHandler.h>
+#include <linux/payload/MpsocCommunication.h>
 #include <linux/payload/PlocMemoryDumper.h>
-#include <linux/payload/PlocMpsocHandler.h>
 #include <linux/payload/PlocMpsocSpecialComHelper.h>
 #include <linux/payload/ScexUartReader.h>
 #include <linux/payload/plocMpsocHelpers.h>
@@ -47,6 +48,7 @@
 #include "devices/gpioIds.h"
 #include "devices/powerSwitcherList.h"
 #include "eive/definitions.h"
+#include "eive/objects.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "linux/ObjectFactory.h"
 #include "linux/boardtest/I2cTestClass.h"
@@ -59,7 +61,11 @@
 #include "linux/ipcore/Ptme.h"
 #include "linux/ipcore/PtmeConfig.h"
 #include "linux/payload/FreshSupvHandler.h"
+#include "linux/payload/MpsocCommunication.h"
+#include "linux/payload/PlocMpsocSpecialComHelper.h"
+#include "linux/payload/SerialConfig.h"
 #include "mission/config/configfile.h"
+#include "mission/power/defs.h"
 #include "mission/system/acs/AcsBoardFdir.h"
 #include "mission/system/acs/AcsSubsystem.h"
 #include "mission/system/acs/RwAssembly.h"
@@ -67,7 +73,7 @@
 #include "mission/system/acs/acsModeTree.h"
 #include "mission/system/com/SyrlinksFdir.h"
 #include "mission/system/com/comModeTree.h"
-#include "mission/system/payloadModeTree.h"
+#include "mission/system/payload/payloadModeTree.h"
 #include "mission/system/power/GomspacePowerFdir.h"
 #include "mission/system/tcs/RtdFdir.h"
 #include "mission/system/tcs/TcsBoardAssembly.h"
@@ -510,7 +516,7 @@ void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF*
   debugGps = true;
 #endif
   RESET_ARGS_GNSS.gpioComIF = gpioComIF;
-  RESET_ARGS_GNSS.waitPeriodMs = 5;
+  RESET_ARGS_GNSS.waitPeriodMs = 10 * 1e3;
   auto gpsCtrl = new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT,
                                                 enableHkSets, debugGps);
   gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);
@@ -624,14 +630,15 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
   auto mpsocGpioCookie = new GpioCookie;
   mpsocGpioCookie->addGpio(gpioIds::ENABLE_MPSOC_UART, gpioConfigMPSoC);
   gpioChecker(gpioComIF->addGpios(mpsocGpioCookie), "PLOC MPSoC");
-  auto mpsocCookie =
-      new SerialCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV,
-                       serial::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
-  mpsocCookie->setNoFixedSizeReply();
-  auto plocMpsocHelper = new PlocMpsocSpecialComHelper(objects::PLOC_MPSOC_HELPER);
-  auto* mpsocHandler = new PlocMpsocHandler(
-      objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie, plocMpsocHelper,
-      Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF), objects::PLOC_SUPERVISOR_HANDLER);
+  SerialConfig serialCfg(q7s::UART_PLOC_MPSOC_DEV, serial::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE,
+                         UartModes::NON_CANONICAL);
+  auto mpsocCommunication = new MpsocCommunication(objects::PLOC_MPSOC_COMMUNICATION, serialCfg);
+  auto specialComHelper =
+      new PlocMpsocSpecialComHelper(objects::PLOC_MPSOC_HELPER, *mpsocCommunication);
+  DhbConfig dhbConf(objects::PLOC_MPSOC_HANDLER);
+  auto* mpsocHandler = new FreshMpsocHandler(
+      dhbConf, *mpsocCommunication, *specialComHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF),
+      objects::PLOC_SUPERVISOR_HANDLER, pwrSwitcher, power::PDU2_CH8_PAYLOAD_CAMERA);
   mpsocHandler->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 #endif /* OBSW_ADD_PLOC_MPSOC == 1 */
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
@@ -650,7 +657,7 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
                        supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
   supervisorCookie->setNoFixedSizeReply();
   new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
-  DhbConfig dhbConf(objects::PLOC_SUPERVISOR_HANDLER);
+  dhbConf = DhbConfig(objects::PLOC_SUPERVISOR_HANDLER);
   auto* supvHandler =
       new FreshSupvHandler(dhbConf, supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),
                            pwrSwitcher, power::PDU1_CH6_PLOC_12V);
@@ -951,7 +958,7 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher, SdCardManage
   auto cfgGetter = new StrConfigPathGetter(sdcMan);
   auto starTracker =
       new StarTrackerHandler(objects::STAR_TRACKER, objects::STR_COM_IF, starTrackerCookie,
-                             strComIF, power::PDU1_CH2_STAR_TRACKER_5V, *cfgGetter);
+                             strComIF, power::PDU1_CH2_STAR_TRACKER_5V, *cfgGetter, sdcMan);
   starTracker->setPowerSwitcher(pwrSwitcher);
   starTracker->connectModeTreeParent(*strAssy);
   starTracker->setCustomFdir(strFdir);

common/config/eive/definitions.h

@@ -20,6 +20,9 @@ static constexpr char OBSW_VERSION_FILE_PATH[] = "/usr/share/eive-obsw/obsw_vers
 // ISO8601 timestamp.
 static constexpr char FILE_DATE_FORMAT[] = "%FT%H%M%SZ";
 
+// Leap Seconds as of 2024-03-04
+static constexpr uint16_t LEAP_SECONDS = 37;
+
 static constexpr uint16_t EIVE_PUS_APID = 0x65;
 static constexpr uint16_t EIVE_CFDP_APID = 0x66;
 static constexpr uint16_t EIVE_LOCAL_CFDP_ENTITY_ID = EIVE_CFDP_APID;

common/config/eive/objects.h

@@ -77,6 +77,7 @@ enum commonObjects : uint32_t {
   PLOC_MPSOC_HANDLER = 0x44330015,
   PLOC_SUPERVISOR_HANDLER = 0x44330016,
   PLOC_SUPERVISOR_HELPER = 0x44330017,
+  PLOC_MPSOC_COMMUNICATION = 0x44330018,
   SCEX = 0x44330032,
   SOLAR_ARRAY_DEPL_HANDLER = 0x444100A2,
   HEATER_HANDLER = 0x444100A4,

common/config/eive/resultClassIds.h

@@ -42,6 +42,7 @@ enum commonClassIds : uint8_t {
   PERSISTENT_TM_STORE,      // PTM
   TM_SINK,                  // TMS
   VIRTUAL_CHANNEL,          // VCS
+  PLOC_MPSOC_COM,           // PLMPCOM
   COMMON_CLASS_ID_END       // [EXPORT] : [END]
 };
 }

dummies/GpsCtrlDummy.h

@@ -2,7 +2,7 @@
 #define DUMMIES_GPSCTRLDUMMY_H_
 
 #include <fsfw/controller/ExtendedControllerBase.h>
-#include <mission/acs/archive/GPSDefinitions.h>
+#include <linux/acs/GPSDefinitions.h>
 
 class GpsCtrlDummy : public ExtendedControllerBase {
  public:

dummies/GpsDhbDummy.cpp

@@ -1,5 +1,5 @@
 #include <dummies/GpsDhbDummy.h>
-#include <mission/acs/archive/GPSDefinitions.h>
+#include <linux/acs/GPSDefinitions.h>
 
 GpsDhbDummy::GpsDhbDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
     : DeviceHandlerBase(objectId, comif, comCookie) {}

dummies/helperFactory.cpp

@@ -40,7 +40,7 @@
 #include "mission/genericFactory.h"
 #include "mission/system/acs/acsModeTree.h"
 #include "mission/system/com/comModeTree.h"
-#include "mission/system/payloadModeTree.h"
+#include "mission/system/payload/payloadModeTree.h"
 #include "mission/system/tcs/tcsModeTree.h"
 #include "mission/tcs/defs.h"
 

fsfw

@@ -1 +1 @@
-Subproject commit b5e7179af1da085b9be598b4897f2664012781af
+Subproject commit 42867ad0cba088ab1cb6cb672d001f991f7e4a60

generators/bsp_hosted_events.csv

@@ -75,9 +75,12 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 7902;0x1ede;BIT_LOCK;INFO;A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7903;0x1edf;BIT_LOCK_LOST;INFO;A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7905;0x1ee1;FRAME_PROCESSING_FAILED;LOW;The CCSDS Board could not interpret a TC;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
-8900;0x22c4;CLOCK_SET;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8901;0x22c5;CLOCK_DUMP;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8902;0x22c6;CLOCK_SET_FAILURE;LOW;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8900;0x22c4;CLOCK_SET;INFO;Clock has been set. P1: old timeval seconds. P2: new timeval seconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8901;0x22c5;CLOCK_DUMP_LEGACY;INFO;Clock dump event. P1: timeval seconds P2: timeval milliseconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8902;0x22c6;CLOCK_SET_FAILURE;LOW;Clock could not be set. P1: Returncode.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8903;0x22c7;CLOCK_DUMP;INFO;Clock dump event. P1: timeval seconds P2: timeval microseconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8904;0x22c8;CLOCK_DUMP_BEFORE_SETTING_TIME;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8905;0x22c9;CLOCK_DUMP_AFTER_SETTING_TIME;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
 9100;0x238c;TC_DELETION_FAILED;MEDIUM;Deletion of a TC from the map failed. P1: First 32 bit of request ID, P2. Last 32 bit of Request ID;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 9700;0x25e4;TEST;INFO;No description;fsfw/src/fsfw/pus/Service17Test.h
 10600;0x2968;CHANGE_OF_SETUP_PARAMETER;LOW;No description;fsfw/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
@@ -98,6 +101,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11208;0x2bc8;TLE_TOO_OLD;INFO;The TLE for the SGP4 Propagator has become too old.;mission/acs/defs.h
 11209;0x2bc9;TLE_FILE_READ_FAILED;LOW;The TLE could not be read from the filesystem.;mission/acs/defs.h
 11210;0x2bca;PTG_RATE_VIOLATION;MEDIUM;The limits for the rotation in pointing mode were violated.;mission/acs/defs.h
+11211;0x2bcb;DETUMBLE_TRANSITION_FAILED;HIGH;The detumble transition has failed. //! P1: Last detumble state before failure.;mission/acs/defs.h
 11300;0x2c24;SWITCH_CMD_SENT;INFO;Indicates that a FSFW object requested setting a switch P1: 1 if on was requested, 0 for off | P2: Switch Index;mission/power/defs.h
 11301;0x2c25;SWITCH_HAS_CHANGED;INFO;Indicated that a switch state has changed P1: New switch state, 1 for on, 0 for off | P2: Switch Index;mission/power/defs.h
 11302;0x2c26;SWITCHING_Q7S_DENIED;MEDIUM;No description;mission/power/defs.h
@@ -124,14 +128,15 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11506;0x2cf2;DEPL_SA1_GPIO_SWTICH_OFF_FAILED;HIGH;No description;mission/SolarArrayDeploymentHandler.h
 11507;0x2cf3;DEPL_SA2_GPIO_SWTICH_OFF_FAILED;HIGH;No description;mission/SolarArrayDeploymentHandler.h
 11508;0x2cf4;AUTONOMOUS_DEPLOYMENT_COMPLETED;INFO;No description;mission/SolarArrayDeploymentHandler.h
-11601;0x2d51;MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC crc failure in telemetry packet;linux/payload/PlocMpsocHandler.h
-11602;0x2d52;ACK_FAILURE;LOW;PLOC receive acknowledgment failure report P1: Command Id which leads the acknowledgment failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/PlocMpsocHandler.h
-11603;0x2d53;EXE_FAILURE;LOW;PLOC receive execution failure report P1: Command Id which leads the execution failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/PlocMpsocHandler.h
-11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/payload/PlocMpsocHandler.h
-11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/payload/PlocMpsocHandler.h
-11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/payload/PlocMpsocHandler.h
-11607;0x2d57;SUPV_NOT_ON;LOW;SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for ON transition.;linux/payload/PlocMpsocHandler.h
-11608;0x2d58;SUPV_REPLY_TIMEOUT;LOW;No description;linux/payload/PlocMpsocHandler.h
+11601;0x2d51;MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC crc failure in telemetry packet;linux/payload/plocMpsocHelpers.h
+11602;0x2d52;ACK_FAILURE;LOW;PLOC receive acknowledgment failure report P1: Command Id which leads the acknowledgment failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/plocMpsocHelpers.h
+11603;0x2d53;EXE_FAILURE;LOW;PLOC receive execution failure report P1: Command Id which leads the execution failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/plocMpsocHelpers.h
+11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/payload/plocMpsocHelpers.h
+11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/payload/plocMpsocHelpers.h
+11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/payload/plocMpsocHelpers.h
+11607;0x2d57;SUPV_NOT_ON;LOW;SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for ON transition.;linux/payload/plocMpsocHelpers.h
+11608;0x2d58;SUPV_REPLY_TIMEOUT;LOW;SUPV reply timeout.;linux/payload/plocMpsocHelpers.h
+11609;0x2d59;CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE;LOW;Camera must be commanded on first.;linux/payload/plocMpsocHelpers.h
 11701;0x2db5;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11702;0x2db6;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11703;0x2db7;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
@@ -232,8 +237,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12902;0x3266;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;No description;mission/system/acs/SusAssembly.h
 12903;0x3267;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/acs/SusAssembly.h
 13000;0x32c8;CHILDREN_LOST_MODE;MEDIUM;No description;mission/system/tcs/TcsBoardAssembly.h
-13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: Old fix. P2: New fix 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;mission/acs/archive/GPSDefinitions.h
-13101;0x332d;CANT_GET_FIX;LOW;Could not get fix in maximum allowed time. P1: Maximum allowed time to get a fix after the GPS was switched on.;mission/acs/archive/GPSDefinitions.h
+13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: New fix. P2: Missed fix changes 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;linux/acs/GPSDefinitions.h
+13101;0x332d;CANT_GET_FIX;MEDIUM;Could not get fix in maximum allowed time. Trying to reset both GNSS devices. P1: Maximum allowed time to get a fix after the GPS was switched on.;linux/acs/GPSDefinitions.h
+13102;0x332e;RESET_FAIL;HIGH;Failed to reset an GNNS Device. P1: Board-Side.;linux/acs/GPSDefinitions.h
 13200;0x3390;P60_BOOT_COUNT;INFO;P60 boot count is broadcasted once at SW startup. P1: Boot count;mission/power/P60DockHandler.h
 13201;0x3391;BATT_MODE;INFO;Battery mode is broadcasted at startup. P1: Mode;mission/power/P60DockHandler.h
 13202;0x3392;BATT_MODE_CHANGED;MEDIUM;Battery mode has changed. P1: Old mode. P2: New mode;mission/power/P60DockHandler.h

generators/bsp_hosted_objects.csv

@@ -57,6 +57,7 @@
 0x44330015;PLOC_MPSOC_HANDLER
 0x44330016;PLOC_SUPERVISOR_HANDLER
 0x44330017;PLOC_SUPERVISOR_HELPER
+0x44330018;PLOC_MPSOC_COMMUNICATION
 0x44330032;SCEX
 0x444100A2;SOLAR_ARRAY_DEPL_HANDLER
 0x444100A4;HEATER_HANDLER

generators/bsp_q7s_events.csv

@@ -75,9 +75,12 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 7902;0x1ede;BIT_LOCK;INFO;A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7903;0x1edf;BIT_LOCK_LOST;INFO;A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7905;0x1ee1;FRAME_PROCESSING_FAILED;LOW;The CCSDS Board could not interpret a TC;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
-8900;0x22c4;CLOCK_SET;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8901;0x22c5;CLOCK_DUMP;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8902;0x22c6;CLOCK_SET_FAILURE;LOW;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8900;0x22c4;CLOCK_SET;INFO;Clock has been set. P1: old timeval seconds. P2: new timeval seconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8901;0x22c5;CLOCK_DUMP_LEGACY;INFO;Clock dump event. P1: timeval seconds P2: timeval milliseconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8902;0x22c6;CLOCK_SET_FAILURE;LOW;Clock could not be set. P1: Returncode.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8903;0x22c7;CLOCK_DUMP;INFO;Clock dump event. P1: timeval seconds P2: timeval microseconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8904;0x22c8;CLOCK_DUMP_BEFORE_SETTING_TIME;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8905;0x22c9;CLOCK_DUMP_AFTER_SETTING_TIME;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
 9100;0x238c;TC_DELETION_FAILED;MEDIUM;Deletion of a TC from the map failed. P1: First 32 bit of request ID, P2. Last 32 bit of Request ID;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 9700;0x25e4;TEST;INFO;No description;fsfw/src/fsfw/pus/Service17Test.h
 10600;0x2968;CHANGE_OF_SETUP_PARAMETER;LOW;No description;fsfw/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
@@ -98,6 +101,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11208;0x2bc8;TLE_TOO_OLD;INFO;The TLE for the SGP4 Propagator has become too old.;mission/acs/defs.h
 11209;0x2bc9;TLE_FILE_READ_FAILED;LOW;The TLE could not be read from the filesystem.;mission/acs/defs.h
 11210;0x2bca;PTG_RATE_VIOLATION;MEDIUM;The limits for the rotation in pointing mode were violated.;mission/acs/defs.h
+11211;0x2bcb;DETUMBLE_TRANSITION_FAILED;HIGH;The detumble transition has failed. //! P1: Last detumble state before failure.;mission/acs/defs.h
 11300;0x2c24;SWITCH_CMD_SENT;INFO;Indicates that a FSFW object requested setting a switch P1: 1 if on was requested, 0 for off | P2: Switch Index;mission/power/defs.h
 11301;0x2c25;SWITCH_HAS_CHANGED;INFO;Indicated that a switch state has changed P1: New switch state, 1 for on, 0 for off | P2: Switch Index;mission/power/defs.h
 11302;0x2c26;SWITCHING_Q7S_DENIED;MEDIUM;No description;mission/power/defs.h
@@ -124,14 +128,15 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11506;0x2cf2;DEPL_SA1_GPIO_SWTICH_OFF_FAILED;HIGH;No description;mission/SolarArrayDeploymentHandler.h
 11507;0x2cf3;DEPL_SA2_GPIO_SWTICH_OFF_FAILED;HIGH;No description;mission/SolarArrayDeploymentHandler.h
 11508;0x2cf4;AUTONOMOUS_DEPLOYMENT_COMPLETED;INFO;No description;mission/SolarArrayDeploymentHandler.h
-11601;0x2d51;MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC crc failure in telemetry packet;linux/payload/PlocMpsocHandler.h
-11602;0x2d52;ACK_FAILURE;LOW;PLOC receive acknowledgment failure report P1: Command Id which leads the acknowledgment failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/PlocMpsocHandler.h
-11603;0x2d53;EXE_FAILURE;LOW;PLOC receive execution failure report P1: Command Id which leads the execution failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/PlocMpsocHandler.h
-11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/payload/PlocMpsocHandler.h
-11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/payload/PlocMpsocHandler.h
-11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/payload/PlocMpsocHandler.h
-11607;0x2d57;SUPV_NOT_ON;LOW;SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for ON transition.;linux/payload/PlocMpsocHandler.h
-11608;0x2d58;SUPV_REPLY_TIMEOUT;LOW;No description;linux/payload/PlocMpsocHandler.h
+11601;0x2d51;MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC crc failure in telemetry packet;linux/payload/plocMpsocHelpers.h
+11602;0x2d52;ACK_FAILURE;LOW;PLOC receive acknowledgment failure report P1: Command Id which leads the acknowledgment failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/plocMpsocHelpers.h
+11603;0x2d53;EXE_FAILURE;LOW;PLOC receive execution failure report P1: Command Id which leads the execution failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/plocMpsocHelpers.h
+11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/payload/plocMpsocHelpers.h
+11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/payload/plocMpsocHelpers.h
+11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/payload/plocMpsocHelpers.h
+11607;0x2d57;SUPV_NOT_ON;LOW;SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for ON transition.;linux/payload/plocMpsocHelpers.h
+11608;0x2d58;SUPV_REPLY_TIMEOUT;LOW;SUPV reply timeout.;linux/payload/plocMpsocHelpers.h
+11609;0x2d59;CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE;LOW;Camera must be commanded on first.;linux/payload/plocMpsocHelpers.h
 11701;0x2db5;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11702;0x2db6;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11703;0x2db7;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
@@ -232,8 +237,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12902;0x3266;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;No description;mission/system/acs/SusAssembly.h
 12903;0x3267;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/acs/SusAssembly.h
 13000;0x32c8;CHILDREN_LOST_MODE;MEDIUM;No description;mission/system/tcs/TcsBoardAssembly.h
-13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: Old fix. P2: New fix 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;mission/acs/archive/GPSDefinitions.h
-13101;0x332d;CANT_GET_FIX;LOW;Could not get fix in maximum allowed time. P1: Maximum allowed time to get a fix after the GPS was switched on.;mission/acs/archive/GPSDefinitions.h
+13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: New fix. P2: Missed fix changes 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;linux/acs/GPSDefinitions.h
+13101;0x332d;CANT_GET_FIX;MEDIUM;Could not get fix in maximum allowed time. Trying to reset both GNSS devices. P1: Maximum allowed time to get a fix after the GPS was switched on.;linux/acs/GPSDefinitions.h
+13102;0x332e;RESET_FAIL;HIGH;Failed to reset an GNNS Device. P1: Board-Side.;linux/acs/GPSDefinitions.h
 13200;0x3390;P60_BOOT_COUNT;INFO;P60 boot count is broadcasted once at SW startup. P1: Boot count;mission/power/P60DockHandler.h
 13201;0x3391;BATT_MODE;INFO;Battery mode is broadcasted at startup. P1: Mode;mission/power/P60DockHandler.h
 13202;0x3392;BATT_MODE_CHANGED;MEDIUM;Battery mode has changed. P1: Old mode. P2: New mode;mission/power/P60DockHandler.h

generators/bsp_q7s_objects.csv

@@ -56,6 +56,7 @@
 0x44330015;PLOC_MPSOC_HANDLER
 0x44330016;PLOC_SUPERVISOR_HANDLER
 0x44330017;PLOC_SUPERVISOR_HELPER
+0x44330018;PLOC_MPSOC_COMMUNICATION
 0x44330032;SCEX
 0x444100A2;SOLAR_ARRAY_DEPL_HANDLER
 0x444100A4;HEATER_HANDLER

generators/bsp_q7s_returnvalues.csv

@@ -561,16 +561,17 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x67a2;SADPL_MainSwitchTimeoutFailure;No description;162;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
 0x67a3;SADPL_SwitchingDeplSa1Failed;No description;163;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
 0x67a4;SADPL_SwitchingDeplSa2Failed;No description;164;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x68a0;MPSOCRTVIF_CrcFailure;Space Packet received from PLOC has invalid CRC;160;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x68a1;MPSOCRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC;161;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x68a2;MPSOCRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC;162;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x68a3;MPSOCRTVIF_InvalidApid;Received space packet with invalid APID from PLOC;163;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x68a4;MPSOCRTVIF_InvalidLength;Received command with invalid length;164;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x68a5;MPSOCRTVIF_FilenameTooLong;Filename of file in OBC filesystem is too long;165;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x68a6;MPSOCRTVIF_MpsocHelperExecuting;MPSoC helper is currently executing a command;166;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x68a7;MPSOCRTVIF_MpsocFilenameTooLong;Filename of MPSoC file is to long (max. 256 bytes);167;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x68a8;MPSOCRTVIF_InvalidParameter;Command has invalid parameter;168;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x68a9;MPSOCRTVIF_NameTooLong;Received command has file string with invalid length;169;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
+0x6810;MPSOCRTVIF_CommandTimeout;Command has timed out.;16;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a0;MPSOCRTVIF_CrcFailure;Space Packet received from PLOC has invalid CRC;160;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a1;MPSOCRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC;161;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a2;MPSOCRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC;162;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a3;MPSOCRTVIF_InvalidApid;Received space packet with invalid APID from PLOC;163;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a4;MPSOCRTVIF_InvalidLength;Received command with invalid length;164;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a5;MPSOCRTVIF_FilenameTooLong;Filename of file in OBC filesystem is too long;165;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a6;MPSOCRTVIF_MpsocHelperExecuting;MPSoC helper is currently executing a command;166;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a7;MPSOCRTVIF_MpsocFilenameTooLong;Filename of MPSoC file is to long (max. 256 bytes);167;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a8;MPSOCRTVIF_InvalidParameter;Command has invalid parameter;168;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a9;MPSOCRTVIF_NameTooLong;Received command has file string with invalid length;169;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
 0x69a0;SPVRTVIF_CrcFailure;Space Packet received from PLOC supervisor has invalid CRC;160;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
 0x69a1;SPVRTVIF_InvalidServiceId;No description;161;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
 0x69a2;SPVRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC supervisor;162;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
@@ -626,4 +627,7 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x6f02;TMS_NoWriteActive;No description;2;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x6f03;TMS_Timeout;No description;3;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x7000;VCS_ChannelDoesNotExist;No description;0;VIRTUAL_CHANNEL;mission/com/VirtualChannel.h
-0x7200;SCBU_KeyNotFound;No description;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h
+0x7100;PLMPCOM_PacketReceived;No description;0;PLOC_MPSOC_COM;linux/payload/MpsocCommunication.h
+0x7101;PLMPCOM_FaultyPacketSize;No description;1;PLOC_MPSOC_COM;linux/payload/MpsocCommunication.h
+0x7102;PLMPCOM_CrcCheckFailed;No description;2;PLOC_MPSOC_COM;linux/payload/MpsocCommunication.h
+0x7300;SCBU_KeyNotFound;No description;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 319 translations.
+ * @brief    Auto-generated event translation file. Contains 325 translations.
  * @details
- * Generated on: 2024-01-30 09:10:05
+ * Generated on: 2024-05-06 13:47:38
  */
 #include "translateEvents.h"
 
@@ -82,8 +82,11 @@ const char *BIT_LOCK_STRING = "BIT_LOCK";
 const char *BIT_LOCK_LOST_STRING = "BIT_LOCK_LOST";
 const char *FRAME_PROCESSING_FAILED_STRING = "FRAME_PROCESSING_FAILED";
 const char *CLOCK_SET_STRING = "CLOCK_SET";
-const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
+const char *CLOCK_DUMP_LEGACY_STRING = "CLOCK_DUMP_LEGACY";
 const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
+const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
+const char *CLOCK_DUMP_BEFORE_SETTING_TIME_STRING = "CLOCK_DUMP_BEFORE_SETTING_TIME";
+const char *CLOCK_DUMP_AFTER_SETTING_TIME_STRING = "CLOCK_DUMP_AFTER_SETTING_TIME";
 const char *TC_DELETION_FAILED_STRING = "TC_DELETION_FAILED";
 const char *TEST_STRING = "TEST";
 const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
@@ -104,6 +107,7 @@ const char *SAFE_MODE_CONTROLLER_FAILURE_STRING = "SAFE_MODE_CONTROLLER_FAILURE"
 const char *TLE_TOO_OLD_STRING = "TLE_TOO_OLD";
 const char *TLE_FILE_READ_FAILED_STRING = "TLE_FILE_READ_FAILED";
 const char *PTG_RATE_VIOLATION_STRING = "PTG_RATE_VIOLATION";
+const char *DETUMBLE_TRANSITION_FAILED_STRING = "DETUMBLE_TRANSITION_FAILED";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
@@ -138,6 +142,7 @@ const char *MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUEN
 const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
 const char *SUPV_NOT_ON_STRING = "SUPV_NOT_ON";
 const char *SUPV_REPLY_TIMEOUT_STRING = "SUPV_REPLY_TIMEOUT";
+const char *CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE_STRING = "CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@@ -240,6 +245,7 @@ const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903_STRING = "SIDE_SWITCH_TRANS
 const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
 const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
 const char *CANT_GET_FIX_STRING = "CANT_GET_FIX";
+const char *RESET_FAIL_STRING = "RESET_FAIL";
 const char *P60_BOOT_COUNT_STRING = "P60_BOOT_COUNT";
 const char *BATT_MODE_STRING = "BATT_MODE";
 const char *BATT_MODE_CHANGED_STRING = "BATT_MODE_CHANGED";
@@ -482,9 +488,15 @@ const char *translateEvents(Event event) {
     case (8900):
       return CLOCK_SET_STRING;
     case (8901):
-      return CLOCK_DUMP_STRING;
+      return CLOCK_DUMP_LEGACY_STRING;
     case (8902):
       return CLOCK_SET_FAILURE_STRING;
+    case (8903):
+      return CLOCK_DUMP_STRING;
+    case (8904):
+      return CLOCK_DUMP_BEFORE_SETTING_TIME_STRING;
+    case (8905):
+      return CLOCK_DUMP_AFTER_SETTING_TIME_STRING;
     case (9100):
       return TC_DELETION_FAILED_STRING;
     case (9700):
@@ -525,6 +537,8 @@ const char *translateEvents(Event event) {
       return TLE_FILE_READ_FAILED_STRING;
     case (11210):
       return PTG_RATE_VIOLATION_STRING;
+    case (11211):
+      return DETUMBLE_TRANSITION_FAILED_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -593,6 +607,8 @@ const char *translateEvents(Event event) {
       return SUPV_NOT_ON_STRING;
     case (11608):
       return SUPV_REPLY_TIMEOUT_STRING;
+    case (11609):
+      return CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE_STRING;
     case (11701):
       return SELF_TEST_I2C_FAILURE_STRING;
     case (11702):
@@ -797,6 +813,8 @@ const char *translateEvents(Event event) {
       return GPS_FIX_CHANGE_STRING;
     case (13101):
       return CANT_GET_FIX_STRING;
+    case (13102):
+      return RESET_FAIL_STRING;
     case (13200):
       return P60_BOOT_COUNT_STRING;
     case (13201):

generators/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 179 translations.
- * Generated on: 2024-01-30 09:10:05
+ * Contains 180 translations.
+ * Generated on: 2024-05-06 13:47:38
  */
 #include "translateObjects.h"
 
@@ -64,6 +64,7 @@ const char *PTME_VC3_CFDP_TM_STRING = "PTME_VC3_CFDP_TM";
 const char *PLOC_MPSOC_HANDLER_STRING = "PLOC_MPSOC_HANDLER";
 const char *PLOC_SUPERVISOR_HANDLER_STRING = "PLOC_SUPERVISOR_HANDLER";
 const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER";
+const char *PLOC_MPSOC_COMMUNICATION_STRING = "PLOC_MPSOC_COMMUNICATION";
 const char *SCEX_STRING = "SCEX";
 const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
 const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
@@ -304,6 +305,8 @@ const char *translateObject(object_id_t object) {
       return PLOC_SUPERVISOR_HANDLER_STRING;
     case 0x44330017:
       return PLOC_SUPERVISOR_HELPER_STRING;
+    case 0x44330018:
+      return PLOC_MPSOC_COMMUNICATION_STRING;
     case 0x44330032:
       return SCEX_STRING;
     case 0x444100A2:

linux/ObjectFactory.cpp

@@ -26,7 +26,7 @@
 #include "devConf.h"
 #include "devices/gpioIds.h"
 #include "mission/system/acs/acsModeTree.h"
-#include "mission/system/payloadModeTree.h"
+#include "mission/system/payload/payloadModeTree.h"
 #include "mission/system/power/epsModeTree.h"
 
 void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF,

linux/acs/GPSDefinitions.h

@@ -7,15 +7,19 @@
 
 namespace GpsHyperion {
 
-enum class FixMode : uint8_t { NOT_SEEN = 0, NO_FIX = 1, FIX_2D = 2, FIX_3D = 3, UNKNOWN = 4 };
+enum FixMode : uint8_t { NOT_SEEN = 0, NO_FIX = 1, FIX_2D = 2, FIX_3D = 3 };
+
+enum GnssChip : uint8_t { A_SIDE = 0, B_SIDE = 1 };
 
 static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::GPS_HANDLER;
-//! [EXPORT] : [COMMENT] Fix has changed. P1: Old fix. P2: New fix
+//! [EXPORT] : [COMMENT] Fix has changed. P1: New fix. P2: Missed fix changes
 //! 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix
 static constexpr Event GPS_FIX_CHANGE = event::makeEvent(SUBSYSTEM_ID, 0, severity::INFO);
-//! [EXPORT] : [COMMENT] Could not get fix in maximum allowed time. P1: Maximum allowed time
-//! to get a fix after the GPS was switched on.
-static constexpr Event CANT_GET_FIX = event::makeEvent(SUBSYSTEM_ID, 1, severity::LOW);
+//! [EXPORT] : [COMMENT] Could not get fix in maximum allowed time. Trying to reset both GNSS
+//! devices. P1: Maximum allowed time to get a fix after the GPS was switched on.
+static constexpr Event CANT_GET_FIX = event::makeEvent(SUBSYSTEM_ID, 1, severity::MEDIUM);
+//! [EXPORT] : [COMMENT] Failed to reset an GNNS Device. P1: Board-Side.
+static constexpr Event RESET_FAIL = event::makeEvent(SUBSYSTEM_ID, 2, severity::HIGH);
 
 static constexpr DeviceCommandId_t GPS_REPLY = 0;
 static constexpr DeviceCommandId_t TRIGGER_RESET_PIN_GNSS = 5;
@@ -53,8 +57,6 @@ static constexpr uint8_t SKYVIEW_ENTRIES = 6;
 
 static constexpr uint8_t MAX_SATELLITES = 30;
 
-enum GpsFixModes : uint8_t { INVALID = 0, NO_FIX = 1, FIX_2D = 2, FIX_3D = 3 };
-
 }  // namespace GpsHyperion
 
 class GpsPrimaryDataset : public StaticLocalDataSet<GpsHyperion::CORE_DATASET_ENTRIES> {

linux/acs/GpsHyperionLinuxController.cpp

@@ -44,24 +44,21 @@ LocalPoolDataSetBase *GpsHyperionLinuxController::getDataSetHandle(sid_t sid) {
 
 ReturnValue_t GpsHyperionLinuxController::checkModeCommand(Mode_t mode, Submode_t submode,
                                                            uint32_t *msToReachTheMode) {
-  if (not modeCommanded) {
-    if (mode == MODE_ON or mode == MODE_OFF) {
-      // 5h time to reach fix
-      *msToReachTheMode = MAX_SECONDS_TO_REACH_FIX;
+  if (mode == MODE_ON) {
     maxTimeToReachFix.resetTimer();
-      modeCommanded = true;
+    gainedNewFix.timeOut();
   } else if (mode == MODE_NORMAL) {
     return HasModesIF::INVALID_MODE;
   }
-  }
   if (mode == MODE_OFF) {
+    maxTimeToReachFix.timeOut();
+    gainedNewFix.timeOut();
     PoolReadGuard pg(&gpsSet);
     gpsSet.setValidity(false, true);
-    // There can't be a fix with a device that is off.
-    triggerEvent(GpsHyperion::GPS_FIX_CHANGE, gpsSet.fixMode.value, 0);
-    gpsSet.fixMode.value = 0;
+    // The ctrl is off, so it cannot detect the data from the devices.
+    handleFixChangedEvent(GpsHyperion::FixMode::NOT_SEEN);
+    gpsSet.fixMode.value = GpsHyperion::FixMode::NOT_SEEN;
     oneShotSwitches.reset();
-    modeCommanded = false;
   }
   return returnvalue::OK;
 }
@@ -75,13 +72,16 @@ ReturnValue_t GpsHyperionLinuxController::executeAction(ActionId_t actionId,
         PoolReadGuard pg(&gpsSet);
         // Set HK entries invalid
         gpsSet.setValidity(false, true);
-        resetCallback(data, size, resetCallbackArgs);
+        ReturnValue_t result = resetCallback(data, size, resetCallbackArgs);
+        if (result != returnvalue::OK) {
+          return result;
+        }
         return HasActionsIF::EXECUTION_FINISHED;
       }
       return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
     }
   }
-  return returnvalue::OK;
+  return HasActionsIF::INVALID_ACTION_ID;
 }
 
 ReturnValue_t GpsHyperionLinuxController::initializeLocalDataPool(
@@ -216,15 +216,9 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
   bool modeIsSet = true;
   if (MODE_SET != (MODE_SET & gps.set)) {
     if (mode != MODE_OFF) {
-      if (maxTimeToReachFix.hasTimedOut() and oneShotSwitches.cantGetFixSwitch) {
-        sif::warning << "GpsHyperionLinuxController: No mode could be set in allowed "
-                     << maxTimeToReachFix.getTimeoutMs() / 1000 << " seconds" << std::endl;
-        triggerEvent(GpsHyperion::CANT_GET_FIX, maxTimeToReachFix.getTimeoutMs());
-        oneShotSwitches.cantGetFixSwitch = false;
-      }
       modeIsSet = false;
     } else {
-      // GPS device is off anyway, so do other handling
+      // GPS ctrl is off anyway, so do other handling
       return returnvalue::FAILED;
     }
   }
@@ -249,27 +243,44 @@ ReturnValue_t GpsHyperionLinuxController::handleCoreTelemetry(bool modeIsSet) {
   uint8_t newFix = 0;
   if (modeIsSet) {
     // 0: Not seen, 1: No fix, 2: 2D-Fix, 3: 3D-Fix
-    if (gps.fix.mode == 2 or gps.fix.mode == 3) {
+    if (gps.fix.mode == GpsHyperion::FixMode::FIX_2D or
+        gps.fix.mode == GpsHyperion::FixMode::FIX_3D) {
       validFix = true;
+      maxTimeToReachFix.resetTimer();
     }
     newFix = gps.fix.mode;
-    if (newFix == 0 or newFix == 1) {
-      if (modeCommanded and maxTimeToReachFix.hasTimedOut()) {
-        // We are supposed to be on and functioning, but no fix was found
-        if (mode == MODE_ON or mode == MODE_NORMAL) {
-          mode = MODE_OFF;
-        }
-        modeCommanded = false;
-      }
-    }
   }
   if (gpsSet.fixMode.value != newFix) {
-#if OBSW_Q7S_EM != 1
-    triggerEvent(GpsHyperion::GPS_FIX_CHANGE, gpsSet.fixMode.value, newFix);
-#endif
+    handleFixChangedEvent(newFix);
   }
   gpsSet.fixMode = newFix;
   gpsSet.fixMode.setValid(modeIsSet);
+  // We are supposed to be on and functioning, but no fix was found
+  if (not validFix) {
+    if (maxTimeToReachFix.hasTimedOut()) {
+      // Set HK entries invalid
+      gpsSet.setValidity(false, true);
+      if (oneShotSwitches.cantGetFixSwitch) {
+        sif::warning << "GpsHyperionLinuxController: No fix detected in allowed "
+                     << maxTimeToReachFix.getTimeoutMs() / 1000 << " seconds" << std::endl;
+        triggerEvent(GpsHyperion::CANT_GET_FIX, maxTimeToReachFix.getTimeoutMs());
+        oneShotSwitches.cantGetFixSwitch = false;
+        // Try resetting the devices
+        if (resetCallback != nullptr) {
+          uint8_t chip = GpsHyperion::GnssChip::A_SIDE;
+          ReturnValue_t result = resetCallback(&chip, 1, resetCallbackArgs);
+          if (result != returnvalue::OK) {
+            triggerEvent(GpsHyperion::RESET_FAIL, chip);
+          }
+          chip = GpsHyperion::GnssChip::B_SIDE;
+          result = resetCallback(&chip, 1, resetCallbackArgs);
+          if (result != returnvalue::OK) {
+            triggerEvent(GpsHyperion::RESET_FAIL, chip);
+          }
+        }
+      }
+    }
+  }
 
   // Only set on specific messages, so only set a valid flag to invalid
   // if not set for more than a full message set (10 messages here)
@@ -282,9 +293,12 @@ ReturnValue_t GpsHyperionLinuxController::handleCoreTelemetry(bool modeIsSet) {
     }
     satNotSetCounter = 0;
   } else {
+    if (satNotSetCounter < 10) {
       satNotSetCounter++;
-    if (gpsSet.satInUse.isValid() and satNotSetCounter >= 10) {
+    } else {
+      gpsSet.satInUse.value = 0;
       gpsSet.satInUse.setValid(false);
+      gpsSet.satInView.value = 0;
       gpsSet.satInView.setValid(false);
     }
   }
@@ -292,12 +306,13 @@ ReturnValue_t GpsHyperionLinuxController::handleCoreTelemetry(bool modeIsSet) {
   // LATLON is set for every message, no need for a counter
   bool latValid = false;
   bool longValid = false;
+  if (modeIsSet) {
     if (LATLON_SET == (LATLON_SET & gps.set)) {
       if (std::isfinite(gps.fix.latitude)) {
         // Negative latitude -> South direction
         gpsSet.latitude.value = gps.fix.latitude;
         // As specified in gps.h: Only valid if mode >= 2
-      if (gps.fix.mode >= 2) {
+        if (gps.fix.mode >= GpsHyperion::FixMode::FIX_2D) {
           latValid = true;
         }
       }
@@ -306,31 +321,36 @@ ReturnValue_t GpsHyperionLinuxController::handleCoreTelemetry(bool modeIsSet) {
         // Negative longitude -> West direction
         gpsSet.longitude.value = gps.fix.longitude;
         // As specified in gps.h: Only valid if mode >= 2
-      if (gps.fix.mode >= 2) {
+        if (gps.fix.mode >= GpsHyperion::FixMode::FIX_2D) {
           longValid = true;
         }
       }
     }
+  }
   gpsSet.latitude.setValid(latValid);
   gpsSet.longitude.setValid(longValid);
 
   // ALTITUDE is set for every message, no need for a counter
   bool altitudeValid = false;
+  if (modeIsSet) {
     if (ALTITUDE_SET == (ALTITUDE_SET & gps.set) && std::isfinite(gps.fix.altitude)) {
       gpsSet.altitude.value = gps.fix.altitude;
       // As specified in gps.h: Only valid if mode == 3
-    if (gps.fix.mode == 3) {
+      if (gps.fix.mode == GpsHyperion::FixMode::FIX_3D) {
         altitudeValid = true;
       }
     }
+  }
   gpsSet.altitude.setValid(altitudeValid);
 
   // SPEED is set for every message, no need for a counter
   bool speedValid = false;
+  if (modeIsSet) {
     if (SPEED_SET == (SPEED_SET & gps.set) && std::isfinite(gps.fix.speed)) {
       gpsSet.speed.value = gps.fix.speed;
       speedValid = true;
     }
+  }
   gpsSet.speed.setValid(speedValid);
 
   // TIME is set for every message, no need for a counter
@@ -430,3 +450,14 @@ void GpsHyperionLinuxController::overwriteTimeIfNotSane(timeval time, bool valid
     timeInit = true;
   }
 }
+
+void GpsHyperionLinuxController::handleFixChangedEvent(uint8_t newFix) {
+  if (gainedNewFix.hasTimedOut()) {
+    triggerEvent(GpsHyperion::GPS_FIX_CHANGE, newFix, fixChangeCounter);
+    fixChangeCounter = 0;
+    gainedNewFix.resetTimer();
+    return;
+  }
+  fixChangeCounter++;
+  gainedNewFix.resetTimer();
+}

linux/acs/GpsHyperionLinuxController.h

@@ -1,14 +1,13 @@
 #ifndef MISSION_DEVICES_GPSHYPERIONHANDLER_H_
 #define MISSION_DEVICES_GPSHYPERIONHANDLER_H_
 
-#include <mission/acs/archive/GPSDefinitions.h>
+#include <common/config/eive/eventSubsystemIds.h>
+#include <fsfw/FSFW.h>
+#include <fsfw/controller/ExtendedControllerBase.h>
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <linux/acs/GPSDefinitions.h>
 #include <mission/utility/trace.h>
 
-#include "eive/eventSubsystemIds.h"
-#include "fsfw/FSFW.h"
-#include "fsfw/controller/ExtendedControllerBase.h"
-#include "fsfw/devicehandlers/DeviceHandlerBase.h"
-
 #ifdef FSFW_OSAL_LINUX
 #include <gps.h>
 #include <libgpsmm.h>
@@ -24,8 +23,8 @@
  */
 class GpsHyperionLinuxController : public ExtendedControllerBase {
  public:
-  // 30 minutes
-  static constexpr uint32_t MAX_SECONDS_TO_REACH_FIX = 60 * 30;
+  // 15 minutes
+  static constexpr uint32_t MAX_SECONDS_TO_REACH_FIX = 60 * 15;
 
   enum ReadModes { SHM = 0, SOCKET = 1 };
 
@@ -65,7 +64,8 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
   const char* currentClientBuf = nullptr;
   ReadModes readMode = ReadModes::SOCKET;
   Countdown maxTimeToReachFix = Countdown(MAX_SECONDS_TO_REACH_FIX * 1000);
-  bool modeCommanded = false;
+  Countdown gainedNewFix = Countdown(60 * 2 * 1000);
+  uint32_t fixChangeCounter = 0;
   bool timeInit = false;
   uint8_t satNotSetCounter = 0;
 
@@ -92,6 +92,8 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
   // we set it with the roughly valid time from the GPS. For some reason, NTP might only work
   // if the time difference between sys time and current time is not too large
   void overwriteTimeIfNotSane(timeval time, bool validFix);
+
+  void handleFixChangedEvent(uint8_t newFix);
 };
 
 #endif /* MISSION_DEVICES_GPSHYPERIONHANDLER_H_ */

linux/acs/StrComHandler.cpp

@@ -175,7 +175,8 @@ void StrComHandler::setDownloadImageName(std::string filename) {
 
 void StrComHandler::setFlashReadFilename(std::string filename) { flashRead.filename = filename; }
 
-ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname) {
+ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname,
+                                                 startracker::FirmwareTarget target) {
   {
     MutexGuard mg(lock);
     if (state != InternalState::SLEEPING) {
@@ -192,8 +193,13 @@ ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname) {
   if (not std::filesystem::exists(flashWrite.fullname)) {
     return FILE_NOT_EXISTS;
   }
-  flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST);
-  flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST);
+  if (target == startracker::FirmwareTarget::MAIN) {
+    flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST_MAIN);
+    flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST_MAIN);
+  } else if (target == startracker::FirmwareTarget::BACKUP) {
+    flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST_BACKUP);
+    flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST_BACKUP);
+  }
   {
     MutexGuard mg(lock);
     replyWasReceived = false;
@@ -264,7 +270,7 @@ ReturnValue_t StrComHandler::performImageDownload() {
       file.close();
       return returnvalue::OK;
     }
-    arc_pack_download_action_req(&downloadReq, cmdBuf.data(), &size);
+    prv_arc_pack_download_action_req(&downloadReq, cmdBuf.data(), &size);
     result = sendAndRead(size, downloadReq.position);
     if (result != returnvalue::OK) {
       if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
@@ -275,7 +281,7 @@ ReturnValue_t StrComHandler::performImageDownload() {
       file.close();
       return result;
     }
-    result = checkActionReply(replySize);
+    result = checkActionReply(replySize, "downloading image");
     if (result != returnvalue::OK) {
       if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
         serial::flushRxBuf(serialPort);
@@ -343,12 +349,12 @@ ReturnValue_t StrComHandler::performImageUpload() {
     }
     file.seekg(uploadReq.position * SIZE_IMAGE_PART, file.beg);
     file.read(reinterpret_cast<char*>(uploadReq.data), SIZE_IMAGE_PART);
-    arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
+    prv_arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
     result = sendAndRead(size, uploadReq.position);
     if (result != returnvalue::OK) {
       return returnvalue::FAILED;
     }
-    result = checkActionReply(replyLen);
+    result = checkActionReply(replyLen, "sky image upload");
     if (result != returnvalue::OK) {
       return result;
     }
@@ -369,12 +375,12 @@ ReturnValue_t StrComHandler::performImageUpload() {
     file.seekg(fullChunks * SIZE_IMAGE_PART, file.beg);
     file.read(reinterpret_cast<char*>(uploadReq.data), remainder);
     file.close();
-    arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
+    prv_arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
     result = sendAndRead(size, uploadReq.position);
     if (result != returnvalue::OK) {
       return returnvalue::FAILED;
     }
-    result = checkActionReply(replyLen);
+    result = checkActionReply(replyLen, "sky image upload");
     if (result != returnvalue::OK) {
       return result;
     }
@@ -388,8 +394,7 @@ ReturnValue_t StrComHandler::performImageUpload() {
 ReturnValue_t StrComHandler::performFirmwareUpdate() {
   using namespace startracker;
   ReturnValue_t result = returnvalue::OK;
-  result = unlockAndEraseRegions(static_cast<uint32_t>(startracker::FirmwareRegions::FIRST),
-                                 static_cast<uint32_t>(startracker::FirmwareRegions::LAST));
+  result = unlockAndEraseRegions(flashWrite.firstRegion, flashWrite.lastRegion);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -440,12 +445,12 @@ ReturnValue_t StrComHandler::performFlashWrite() {
       bytesWrittenInRegion = 0;
     }
     req.address = bytesWrittenInRegion;
-    arc_pack_write_action_req(&req, cmdBuf.data(), &size);
+    prv_arc_pack_write_action_req(&req, cmdBuf.data(), &size);
     result = sendAndRead(size, req.address);
     if (result != returnvalue::OK) {
       return result;
     }
-    result = checkActionReply(replyLen);
+    result = checkActionReply(replyLen, "firmware image upload");
     if (result != returnvalue::OK) {
       return result;
     }
@@ -483,12 +488,12 @@ ReturnValue_t StrComHandler::performFlashWrite() {
     req.length = remainingBytes;
     totalBytesWritten += CHUNK_SIZE;
     bytesWrittenInRegion += remainingBytes;
-    arc_pack_write_action_req(&req, cmdBuf.data(), &size);
+    prv_arc_pack_write_action_req(&req, cmdBuf.data(), &size);
     result = sendAndRead(size, req.address);
     if (result != returnvalue::OK) {
       return result;
     }
-    result = checkActionReply(replyLen);
+    result = checkActionReply(replyLen, "flash write");
     if (result != returnvalue::OK) {
       return result;
     }
@@ -531,7 +536,7 @@ ReturnValue_t StrComHandler::performFlashRead() {
     } else {
       req.length = CHUNK_SIZE;
     }
-    arc_pack_read_action_req(&req, cmdBuf.data(), &size);
+    prv_arc_pack_read_action_req(&req, cmdBuf.data(), &size);
     result = sendAndRead(size, req.address);
     if (result != returnvalue::OK) {
       if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
@@ -542,7 +547,7 @@ ReturnValue_t StrComHandler::performFlashRead() {
       file.close();
       return result;
     }
-    result = checkActionReply(replyLen);
+    result = checkActionReply(replyLen, "flash read");
     if (result != returnvalue::OK) {
       if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
         serial::flushRxBuf(serialPort);
@@ -584,7 +589,7 @@ ReturnValue_t StrComHandler::sendAndRead(size_t size, uint32_t failParameter) {
   return readOneReply(failParameter);
 }
 
-ReturnValue_t StrComHandler::checkActionReply(size_t replySize) {
+ReturnValue_t StrComHandler::checkActionReply(size_t replySize, const char* context) {
   uint8_t type = startracker::getReplyFrameType(replyPtr);
   if (type != TMTC_ACTIONREPLY) {
     sif::warning << "StrHelper::checkActionReply: Received reply with invalid type ID" << std::endl;
@@ -592,7 +597,7 @@ ReturnValue_t StrComHandler::checkActionReply(size_t replySize) {
   }
   uint8_t status = startracker::getStatusField(replyPtr);
   if (status != ArcsecDatalinkLayer::STATUS_OK) {
-    sif::warning << "StrHelper::checkActionReply: Status failure: "
+    sif::warning << "StrHelper::checkActionReply: Status failure for " << context << ": "
                  << static_cast<unsigned int>(status) << std::endl;
     return STATUS_ERROR;
   }
@@ -744,23 +749,26 @@ ReturnValue_t StrComHandler::unlockAndEraseRegions(uint32_t from, uint32_t to) {
   struct UnlockActionRequest unlockReq;
   struct EraseActionRequest eraseReq;
   uint32_t size = 0;
-  for (uint32_t idx = from; idx <= to; idx++) {
+  for (uint32_t idx = from; idx < to; idx++) {
     unlockReq.region = idx;
-    unlockReq.code = startracker::region_secrets::secret[idx];
-    arc_pack_unlock_action_req(&unlockReq, cmdBuf.data(), &size);
+    unlockReq.code = startracker::region_secrets::SECRETS[idx];
+    prv_arc_pack_unlock_action_req(&unlockReq, cmdBuf.data(), &size);
     result = sendAndRead(size, unlockReq.region);
     if (result != returnvalue::OK) {
       return result;
     }
-    result = checkActionReply(replyLen);
+    result = checkActionReply(replyLen, "unlocking region");
     if (result != returnvalue::OK) {
       sif::warning << "StrHelper::unlockAndEraseRegions: Failed to unlock region with id "
                    << static_cast<unsigned int>(unlockReq.region) << std::endl;
       return result;
     }
     eraseReq.region = idx;
-    arc_pack_erase_action_req(&eraseReq, cmdBuf.data(), &size);
+    prv_arc_pack_erase_action_req(&eraseReq, cmdBuf.data(), &size);
     result = sendAndRead(size, eraseReq.region);
+    if (result != returnvalue::OK) {
+    }
+    result = checkActionReply(replyLen, "erasing region");
     if (result != returnvalue::OK) {
       sif::warning << "StrHelper::unlockAndEraseRegions: Failed to erase region with id "
                    << static_cast<unsigned int>(eraseReq.region) << std::endl;

linux/acs/StrComHandler.h

@@ -6,6 +6,7 @@
 #include <string>
 
 #include "OBSWConfig.h"
+#include "mission/acs/str/strHelpers.h"
 
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/SdCardManager.h"
@@ -127,7 +128,7 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
    * @param fullname    Full name including absolute path of file containing firmware
    *                    update.
    */
-  ReturnValue_t startFirmwareUpdate(std::string fullname);
+  ReturnValue_t startFirmwareUpdate(std::string fullname, startracker::FirmwareTarget target);
 
   /**
    * @brief   Starts the flash read procedure
@@ -334,7 +335,7 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
    *
    * @return  returnvalue::OK if reply confirms success of packet transfer, otherwise REUTRN_FAILED
    */
-  ReturnValue_t checkActionReply(size_t replySize);
+  ReturnValue_t checkActionReply(size_t replySize, const char *context);
 
   /**
    * @brief   Checks the position field in a star tracker upload/download reply.

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 319 translations.
+ * @brief    Auto-generated event translation file. Contains 325 translations.
  * @details
- * Generated on: 2024-01-30 09:10:05
+ * Generated on: 2024-05-06 13:47:38
  */
 #include "translateEvents.h"
 
@@ -82,8 +82,11 @@ const char *BIT_LOCK_STRING = "BIT_LOCK";
 const char *BIT_LOCK_LOST_STRING = "BIT_LOCK_LOST";
 const char *FRAME_PROCESSING_FAILED_STRING = "FRAME_PROCESSING_FAILED";
 const char *CLOCK_SET_STRING = "CLOCK_SET";
-const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
+const char *CLOCK_DUMP_LEGACY_STRING = "CLOCK_DUMP_LEGACY";
 const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
+const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
+const char *CLOCK_DUMP_BEFORE_SETTING_TIME_STRING = "CLOCK_DUMP_BEFORE_SETTING_TIME";
+const char *CLOCK_DUMP_AFTER_SETTING_TIME_STRING = "CLOCK_DUMP_AFTER_SETTING_TIME";
 const char *TC_DELETION_FAILED_STRING = "TC_DELETION_FAILED";
 const char *TEST_STRING = "TEST";
 const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
@@ -104,6 +107,7 @@ const char *SAFE_MODE_CONTROLLER_FAILURE_STRING = "SAFE_MODE_CONTROLLER_FAILURE"
 const char *TLE_TOO_OLD_STRING = "TLE_TOO_OLD";
 const char *TLE_FILE_READ_FAILED_STRING = "TLE_FILE_READ_FAILED";
 const char *PTG_RATE_VIOLATION_STRING = "PTG_RATE_VIOLATION";
+const char *DETUMBLE_TRANSITION_FAILED_STRING = "DETUMBLE_TRANSITION_FAILED";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
@@ -138,6 +142,7 @@ const char *MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUEN
 const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
 const char *SUPV_NOT_ON_STRING = "SUPV_NOT_ON";
 const char *SUPV_REPLY_TIMEOUT_STRING = "SUPV_REPLY_TIMEOUT";
+const char *CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE_STRING = "CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@@ -240,6 +245,7 @@ const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903_STRING = "SIDE_SWITCH_TRANS
 const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
 const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
 const char *CANT_GET_FIX_STRING = "CANT_GET_FIX";
+const char *RESET_FAIL_STRING = "RESET_FAIL";
 const char *P60_BOOT_COUNT_STRING = "P60_BOOT_COUNT";
 const char *BATT_MODE_STRING = "BATT_MODE";
 const char *BATT_MODE_CHANGED_STRING = "BATT_MODE_CHANGED";
@@ -482,9 +488,15 @@ const char *translateEvents(Event event) {
     case (8900):
       return CLOCK_SET_STRING;
     case (8901):
-      return CLOCK_DUMP_STRING;
+      return CLOCK_DUMP_LEGACY_STRING;
     case (8902):
       return CLOCK_SET_FAILURE_STRING;
+    case (8903):
+      return CLOCK_DUMP_STRING;
+    case (8904):
+      return CLOCK_DUMP_BEFORE_SETTING_TIME_STRING;
+    case (8905):
+      return CLOCK_DUMP_AFTER_SETTING_TIME_STRING;
     case (9100):
       return TC_DELETION_FAILED_STRING;
     case (9700):
@@ -525,6 +537,8 @@ const char *translateEvents(Event event) {
       return TLE_FILE_READ_FAILED_STRING;
     case (11210):
       return PTG_RATE_VIOLATION_STRING;
+    case (11211):
+      return DETUMBLE_TRANSITION_FAILED_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -593,6 +607,8 @@ const char *translateEvents(Event event) {
       return SUPV_NOT_ON_STRING;
     case (11608):
       return SUPV_REPLY_TIMEOUT_STRING;
+    case (11609):
+      return CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE_STRING;
     case (11701):
       return SELF_TEST_I2C_FAILURE_STRING;
     case (11702):
@@ -797,6 +813,8 @@ const char *translateEvents(Event event) {
       return GPS_FIX_CHANGE_STRING;
     case (13101):
       return CANT_GET_FIX_STRING;
+    case (13102):
+      return RESET_FAIL_STRING;
     case (13200):
       return P60_BOOT_COUNT_STRING;
     case (13201):

linux/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 179 translations.
- * Generated on: 2024-01-30 09:10:05
+ * Contains 180 translations.
+ * Generated on: 2024-05-06 13:47:38
  */
 #include "translateObjects.h"
 
@@ -64,6 +64,7 @@ const char *PTME_VC3_CFDP_TM_STRING = "PTME_VC3_CFDP_TM";
 const char *PLOC_MPSOC_HANDLER_STRING = "PLOC_MPSOC_HANDLER";
 const char *PLOC_SUPERVISOR_HANDLER_STRING = "PLOC_SUPERVISOR_HANDLER";
 const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER";
+const char *PLOC_MPSOC_COMMUNICATION_STRING = "PLOC_MPSOC_COMMUNICATION";
 const char *SCEX_STRING = "SCEX";
 const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
 const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
@@ -304,6 +305,8 @@ const char *translateObject(object_id_t object) {
       return PLOC_SUPERVISOR_HANDLER_STRING;
     case 0x44330017:
       return PLOC_SUPERVISOR_HELPER_STRING;
+    case 0x44330018:
+      return PLOC_MPSOC_COMMUNICATION_STRING;
     case 0x44330032:
       return SCEX_STRING;
     case 0x444100A2:

linux/payload/CMakeLists.txt

@@ -1,7 +1,9 @@
 target_sources(
   ${OBSW_NAME}
   PUBLIC PlocMemoryDumper.cpp
-         PlocMpsocHandler.cpp
+         MpsocCommunication.cpp
+         SerialCommunicationHelper.cpp
+         FreshMpsocHandler.cpp
          FreshSupvHandler.cpp
          PlocMpsocSpecialComHelper.cpp
          plocMpsocHelpers.cpp

linux/payload/FreshMpsocHandler.h

@@ -0,0 +1,212 @@
+#include "fsfw/action/ActionMessage.h"
+#include "fsfw/action/CommandsActionsIF.h"
+#include "fsfw/devicehandlers/DeviceHandlerIF.h"
+#include "fsfw/devicehandlers/FreshDeviceHandlerBase.h"
+#include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/ipc/messageQueueDefinitions.h"
+#include "fsfw/modes/ModeMessage.h"
+#include "fsfw/objectmanager/SystemObjectIF.h"
+#include "fsfw/power/PowerSwitchIF.h"
+#include "fsfw/power/definitions.h"
+#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw_hal/linux/gpio/Gpio.h"
+#include "linux/payload/MpsocCommunication.h"
+#include "linux/payload/PlocMpsocSpecialComHelper.h"
+#include "linux/payload/plocMpsocHelpers.h"
+
+class FreshMpsocHandler : public FreshDeviceHandlerBase, public CommandsActionsIF {
+ public:
+  enum OpCode { DEFAULT_OPERATION = 0, PARSE_TM = 1 };
+  static constexpr uint32_t MPSOC_MODE_CMD_TIMEOUT_MS = 120000;
+
+  FreshMpsocHandler(DhbConfig cfg, MpsocCommunication& comInterface,
+                    PlocMpsocSpecialComHelper& specialComHelper, Gpio uartIsolatorSwitch,
+                    object_id_t supervisorHandler, PowerSwitchIF& powerSwitcher,
+                    power::Switch_t camSwitchId);
+
+  /**
+   * Periodic helper executed function, implemented by child class.
+   */
+  void performDeviceOperation(uint8_t opCode) override;
+
+  void performDefaultDeviceOperation();
+
+  /**
+   * Implemented by child class. Handle all command messages which are
+   * not health, mode, action or housekeeping messages.
+   * @param message
+   * @return
+   */
+  ReturnValue_t handleCommandMessage(CommandMessage* message) override;
+
+  ReturnValue_t initialize() override;
+
+ private:
+  enum class StartupState { IDLE, HW_INIT, DONE } startupState = StartupState::IDLE;
+  enum class PowerState { IDLE, PENDING_STARTUP, PENDING_SHUTDOWN, SUPV_FAILED, DONE };
+
+  enum TransitionState { NONE, TO_ON, TO_OFF, SUBMODE } transitionState = TransitionState::NONE;
+  MpsocCommunication& comInterface;
+  PlocMpsocSpecialComHelper& specialComHelper;
+  MessageQueueIF* eventQueue = nullptr;
+  SourceSequenceCounter commandSequenceCount = SourceSequenceCounter(0);
+  MessageQueueIF* commandActionHelperQueue = nullptr;
+  CommandActionHelper commandActionHelper;
+  Gpio uartIsolatorSwitch;
+  mpsoc::HkReport hkReport;
+  object_id_t supervisorHandler;
+
+  Countdown mpsocBootTransitionCd = Countdown(6500);
+  Countdown supvTransitionCd = Countdown(3000);
+
+  PoolEntry<uint32_t> peStatus = PoolEntry<uint32_t>();
+  PoolEntry<uint8_t> peMode = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkPwrOn = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkReplyActive = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkJesdSyncStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peDownlinkDacStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peCameraStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peCameraSdiStatus = PoolEntry<uint8_t>();
+  PoolEntry<float> peCameraFpgaTemp = PoolEntry<float>();
+  PoolEntry<float> peCameraSocTemp = PoolEntry<float>();
+  PoolEntry<float> peSysmonTemp = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccInt = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccAux = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccBram = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccPaux = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccPint = PoolEntry<float>();
+  PoolEntry<float> peSysmonVccPdro = PoolEntry<float>();
+  PoolEntry<float> peSysmonMb12V = PoolEntry<float>();
+  PoolEntry<float> peSysmonMb3V3 = PoolEntry<float>();
+  PoolEntry<float> peSysmonMb1V8 = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc12V = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc5V = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc3V3 = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc3V3VA = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc2V5DDR = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc1V2DDR = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc0V9 = PoolEntry<float>();
+  PoolEntry<float> peSysmonVcc0V6VTT = PoolEntry<float>();
+  PoolEntry<float> peSysmonSafeCotsCur = PoolEntry<float>();
+  PoolEntry<float> peSysmonNvm4XoCur = PoolEntry<float>();
+  PoolEntry<uint16_t> peSemUncorrectableErrs = PoolEntry<uint16_t>();
+  PoolEntry<uint16_t> peSemCorrectableErrs = PoolEntry<uint16_t>();
+  PoolEntry<uint8_t> peSemStatus = PoolEntry<uint8_t>();
+  PoolEntry<uint8_t> peRebootMpsocRequired = PoolEntry<uint8_t>();
+
+  PowerState powerState;
+  bool specialComHelperExecuting = false;
+
+  struct ActionCommandInfo {
+    Countdown cmdCountdown = Countdown(mpsoc::DEFAULT_CMD_TIMEOUT_MS);
+    bool pending = false;
+    MessageQueueId_t commandedBy = MessageQueueIF::NO_QUEUE;
+    DeviceCommandId_t pendingCmd = DeviceHandlerIF::NO_COMMAND_ID;
+    uint16_t pendingCmdMpsocApid = 0;
+
+    void reset() {
+      pending = false;
+      commandedBy = MessageQueueIF::NO_QUEUE;
+      pendingCmd = DeviceHandlerIF::NO_COMMAND_ID;
+    }
+
+    void start(DeviceCommandId_t commandId, MessageQueueId_t commandedBy) {
+      pending = true;
+      cmdCountdown.resetTimer();
+      pendingCmd = commandId;
+      this->commandedBy = commandedBy;
+    }
+  } activeCmdInfo;
+
+  uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE];
+  SpacePacketCreator creator;
+  ploc::SpTcParams spParams = ploc::SpTcParams(creator);
+  Mode_t targetMode = HasModesIF::MODE_UNDEFINED;
+  Submode_t targetSubmode = 0;
+
+  struct TmMemReadReport {
+    static const uint8_t FIX_SIZE = 14;
+    size_t rememberRequestedSize = 0;
+  };
+
+  TmMemReadReport tmMemReadReport;
+  uint32_t lastReplySequenceCount = 0;
+  uint8_t skipSupvCommandingToOn = false;
+  PowerSwitchIF& powerSwitcher;
+  power::Switch_t camSwitchId;
+
+  // HK manager abstract functions.
+  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                        LocalDataPoolManager& poolManager) override;
+
+  // Mode abstract functions
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t* msToReachTheMode) override;
+  // Action override. Forward to user.
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                              const uint8_t* data, size_t size) override;
+
+  /**
+   * @overload
+   * @param submode
+   */
+  void startTransition(Mode_t newMode, Submode_t submode) override;
+
+  ReturnValue_t performDeviceOperationPreQueueHandling(uint8_t opCode) override;
+
+  // CommandsActionsIF overrides.
+  MessageQueueIF* getCommandQueuePtr() override;
+
+  void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) override;
+  void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) override;
+  void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) override;
+  void completionSuccessfulReceived(ActionId_t actionId) override;
+  void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) override;
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper* parameterWrapper,
+                             const ParameterWrapper* newValues, uint16_t startAtIndex) override;
+
+  void handleActionCommandFailure(ActionId_t actionId, ReturnValue_t returnCode);
+  ReturnValue_t executeRegularCmd(ActionId_t actionId, MessageQueueId_t commandedBy,
+                                  const uint8_t* data, size_t dataLen);
+  void handleTransitionToOn();
+  void handleTransitionToOff();
+
+  ReturnValue_t commandTcModeReplay();
+  ReturnValue_t commandTcMemWrite(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcMemRead(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcFlashDelete(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcReplayStart(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcReplayStop();
+  ReturnValue_t commandTcDownlinkPwrOn(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcDownlinkPwrOff();
+  ReturnValue_t commandTcGetHkReport();
+  ReturnValue_t commandTcGetDirContent(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcCamCmdSend(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcModeIdle();
+  ReturnValue_t commandTcCamTakePic(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcSimplexStreamFile(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcSplitFile(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcDownlinkDataModulate(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t commandTcModeSnapshot();
+
+  ReturnValue_t finishAndSendTc(DeviceCommandId_t cmdId, mpsoc::TcBase& tcBase,
+                                uint32_t cmdCountdown = mpsoc::DEFAULT_CMD_TIMEOUT_MS);
+  void handleEvent(EventMessage* eventMessage);
+  void cmdDoneHandler(bool success, ReturnValue_t result);
+  ReturnValue_t handleDeviceReply();
+  ReturnValue_t handleAckReport();
+  ReturnValue_t handleExecutionReport();
+  void sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status);
+  ReturnValue_t reportReplyData(DeviceCommandId_t tmId);
+  ReturnValue_t handleGetHkReport();
+  bool handleHwStartup();
+  bool handleHwShutdown();
+
+  void stopSpecialComHelper();
+  void commandSubmodeTransition();
+  void commonSpecialComInit();
+  void commonSpecialComStop();
+  void commandInitHandling(ActionId_t actionId, MessageQueueId_t commandedBy);
+};

linux/payload/FreshSupvHandler.cpp

@@ -900,6 +900,14 @@ ReturnValue_t FreshSupvHandler::parseTmPackets() {
         }
         break;
       }
+      case (Apid::LATCHUP_MON): {
+        if (tmReader.getServiceId() ==
+            static_cast<uint8_t>(supv::tm::LatchupMonId::LATCHUP_STATUS_REPORT)) {
+          handleLatchupStatusReport(receivedData);
+          continue;
+        }
+        break;
+      }
       case (Apid::ADC_MON): {
         if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::AdcMonId::ADC_REPORT)) {
           genericHandleTm("ADC", receivedData, adcReport, supv::Apid::ADC_MON,
@@ -1291,7 +1299,7 @@ void FreshSupvHandler::handleExecutionFailureReport(ActiveCmdInfo& info, Executi
     triggerEvent(SUPV_EXE_FAILURE, info.commandId, static_cast<uint32_t>(report.getStatusCode()));
   }
   if (info.commandedBy) {
-    actionHelper.finish(false, info.commandedBy, info.commandId, report.getStatusCode());
+    actionHelper.finish(false, info.commandedBy, info.commandId, result::RECEIVED_EXE_FAILURE);
   }
   info.isPending = false;
 }
@@ -1391,15 +1399,17 @@ ReturnValue_t FreshSupvHandler::verifyPacket(const uint8_t* start, size_t foundL
 
 ReturnValue_t FreshSupvHandler::handleBootStatusReport(const uint8_t* data) {
   ReturnValue_t result = returnvalue::OK;
-
   result = verifyPacket(data, tmReader.getFullPacketLen());
-
   if (result == result::CRC_FAILURE) {
     sif::error << "PlocSupervisorHandler::handleBootStatusReport: Boot status report has invalid"
                   " crc"
                << std::endl;
     return result;
   }
+  PoolReadGuard pg(&bootStatusReport);
+  if (pg.getReadResult() != returnvalue::OK) {
+    return pg.getReadResult();
+  }
 
   const uint8_t* payloadStart = tmReader.getPayloadStart();
   uint16_t offset = 0;
@@ -1463,13 +1473,17 @@ ReturnValue_t FreshSupvHandler::handleLatchupStatusReport(const uint8_t* data) {
   ReturnValue_t result = returnvalue::OK;
 
   result = verifyPacket(data, tmReader.getFullPacketLen());
-
   if (result == result::CRC_FAILURE) {
     sif::error << "PlocSupervisorHandler::handleLatchupStatusReport: Latchup status report has "
                << "invalid crc" << std::endl;
     return result;
   }
 
+  PoolReadGuard pg(&latchupStatusReport);
+  if (pg.getReadResult() != returnvalue::OK) {
+    return pg.getReadResult();
+  }
+
   const uint8_t* payloadData = tmReader.getPayloadStart();
   uint16_t offset = 0;
   latchupStatusReport.id = *(payloadData + offset);
@@ -1486,10 +1500,10 @@ ReturnValue_t FreshSupvHandler::handleLatchupStatusReport(const uint8_t* data) {
   offset += 2;
   latchupStatusReport.cnt5 = *(payloadData + offset) << 8 | *(payloadData + offset + 1);
   offset += 2;
-  latchupStatusReport.cnt6 = *(payloadData + offset) << 8 | *(data + offset + 1);
+  latchupStatusReport.cnt6 = *(payloadData + offset) << 8 | *(payloadData + offset + 1);
   offset += 2;
   uint16_t msec = *(payloadData + offset) << 8 | *(payloadData + offset + 1);
-  latchupStatusReport.isSet = msec >> supv::LatchupStatusReport::IS_SET_BIT_POS;
+  latchupStatusReport.isSynced = msec >> supv::LatchupStatusReport::IS_SET_BIT_POS;
   latchupStatusReport.timeMsec = msec & (~(1 << latchupStatusReport.IS_SET_BIT_POS));
   offset += 2;
   latchupStatusReport.timeSec = *(payloadData + offset);

linux/payload/MpsocCommunication.cpp

@@ -0,0 +1,75 @@
+#include "MpsocCommunication.h"
+
+#include "fsfw/globalfunctions/CRC.h"
+#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
+#include "fsfw/tmtcpacket/ccsds/header.h"
+#include "linux/payload/plocMpsocHelpers.h"
+#include "unistd.h"
+
+MpsocCommunication::MpsocCommunication(object_id_t objectId, SerialConfig cfg)
+    : SystemObject(objectId), readRingBuf(4096, true), helper(cfg) {}
+
+ReturnValue_t MpsocCommunication::initialize() { return helper.initialize(); }
+
+ReturnValue_t MpsocCommunication::send(const uint8_t* data, size_t dataLen) {
+  if (MPSOC_LOW_LEVEL_TX_WIRETAPPING) {
+    sif::debug << "SEND MPSOC packet with size " << dataLen << std::endl;
+  }
+  return helper.send(data, dataLen);
+}
+
+ReturnValue_t MpsocCommunication::parseAndRetrieveNextPacket() {
+  // We do not have a data link layer, so this whole thing is a mess in any case..
+  // But basically, we try to parse space packets from the internal ring buffer and trasnfer
+  // them to the higher level device handler. The CRC check is performed here as well, with
+  // few other ways to detect if we even have a valid packet.
+  size_t availableReadData = readRingBuf.getAvailableReadData();
+  // Minimum valid size for a space packet header.
+  if (availableReadData < ccsds::HEADER_LEN + 1) {
+    return returnvalue::OK;
+  }
+  readRingBuf.readData(readBuf, availableReadData);
+  spReader.setReadOnlyData(readBuf, sizeof(readBuf));
+  auto res = spReader.checkSize();
+  if (res != returnvalue::OK) {
+    return res;
+  }
+  // The packet might be garbage, with no way to recover without a data link layer.
+  if (spReader.getFullPacketLen() > 4096) {
+    readRingBuf.clear();
+    // TODO: Maybe we should also clear the serial input buffer in Linux?
+    return FAULTY_PACKET_SIZE;
+  }
+  if (availableReadData < spReader.getFullPacketLen()) {
+    // Might be split packet where the rest still has to be read.
+    return returnvalue::OK;
+  }
+  if (CRC::crc16ccitt(readBuf, spReader.getFullPacketLen()) != 0) {
+    // Possibly invalid packet. We can not even trust the detected packet length.
+    // Just clear the whole read buffer as well.
+    readRingBuf.clear();
+    triggerEvent(mpsoc::CRC_FAILURE);
+    return CRC_CHECK_FAILED;
+  }
+  readRingBuf.deleteData(spReader.getFullPacketLen());
+  return PACKET_RECEIVED;
+}
+
+ReturnValue_t MpsocCommunication::readSerialInterface() {
+  int bytesRead = read(helper.rawFd(), readBuf, sizeof(readBuf));
+  if (bytesRead < 0) {
+    return returnvalue::FAILED;
+  }
+  if (bytesRead > 0) {
+    if (MPSOC_LOW_LEVEL_RX_WIRETAPPING) {
+      sif::debug << "Read " << bytesRead << " bytes on the MPSoC interface" << std::endl;
+    }
+    return readRingBuf.writeData(readBuf, bytesRead);
+  }
+  return returnvalue::OK;
+}
+
+const SpacePacketReader& MpsocCommunication::getSpReader() const { return spReader; }
+
+SerialCommunicationHelper& MpsocCommunication::getComHelper() { return helper; }

linux/payload/MpsocCommunication.h

@@ -0,0 +1,44 @@
+
+#pragma once
+
+#include <fsfw/objectmanager/SystemObject.h>
+
+#include "eive/resultClassIds.h"
+#include "fsfw/container/SimpleRingBuffer.h"
+#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
+#include "linux/payload/SerialCommunicationHelper.h"
+
+static constexpr bool MPSOC_LOW_LEVEL_TX_WIRETAPPING = false;
+static constexpr bool MPSOC_LOW_LEVEL_RX_WIRETAPPING = false;
+
+class MpsocCommunication : public SystemObject {
+ public:
+  static const uint8_t CLASS_ID = CLASS_ID::PLOC_MPSOC_COM;
+  static constexpr ReturnValue_t PACKET_RECEIVED = returnvalue::makeCode(CLASS_ID, 0);
+  static constexpr ReturnValue_t FAULTY_PACKET_SIZE = returnvalue::makeCode(CLASS_ID, 1);
+  static constexpr ReturnValue_t CRC_CHECK_FAILED = returnvalue::makeCode(CLASS_ID, 2);
+
+  MpsocCommunication(object_id_t objectId, SerialConfig cfg);
+  ReturnValue_t initialize() override;
+
+  ReturnValue_t send(const uint8_t* data, size_t dataLen);
+
+  // Should be called periodically to transfer the received data from the MPSoC from the Linux
+  // buffer to the internal ring buffer for further processing.
+  ReturnValue_t readSerialInterface();
+
+  // Parses the internal ring buffer for packets and checks whether a packet was received.
+  ReturnValue_t parseAndRetrieveNextPacket();
+
+  // Can be used to read the parse packet, if one was received.
+  const SpacePacketReader& getSpReader() const;
+
+  SerialCommunicationHelper& getComHelper();
+
+ private:
+  SpacePacketReader spReader;
+  uint8_t readBuf[4096];
+  SimpleRingBuffer readRingBuf;
+  SerialCommunicationHelper helper;
+};

linux/payload/PlocMpsocSpecialComHelper.cpp

@@ -6,16 +6,21 @@
 #include <filesystem>
 #include <fstream>
 
+#include "fsfw/serviceinterface/ServiceInterfacePrinter.h"
+#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
+#include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
+#include "linux/payload/MpsocCommunication.h"
+#include "linux/payload/plocMpsocHelpers.h"
+
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/FilesystemHelper.h"
 #endif
 
-#include "mission/utility/Timestamp.h"
-
 using namespace ploc;
 
-PlocMpsocSpecialComHelper::PlocMpsocSpecialComHelper(object_id_t objectId)
-    : SystemObject(objectId) {
+PlocMpsocSpecialComHelper::PlocMpsocSpecialComHelper(object_id_t objectId,
+                                                     MpsocCommunication& comInterface)
+    : SystemObject(objectId), comInterface(comInterface) {
   spParams.buf = commandBuffer;
   spParams.maxSize = sizeof(commandBuffer);
 }
@@ -48,9 +53,9 @@ ReturnValue_t PlocMpsocSpecialComHelper::performOperation(uint8_t operationCode)
       case InternalState::FLASH_WRITE: {
         result = performFlashWrite();
         if (result == returnvalue::OK) {
-          triggerEvent(MPSOC_FLASH_WRITE_SUCCESSFUL, sequenceCount->get());
+          triggerEvent(MPSOC_FLASH_WRITE_SUCCESSFUL, txSequenceCount.get());
         } else {
-          triggerEvent(MPSOC_FLASH_WRITE_FAILED, sequenceCount->get());
+          triggerEvent(MPSOC_FLASH_WRITE_FAILED, txSequenceCount.get());
         }
         internalState = InternalState::IDLE;
         break;
@@ -58,9 +63,10 @@ ReturnValue_t PlocMpsocSpecialComHelper::performOperation(uint8_t operationCode)
       case InternalState::FLASH_READ: {
         result = performFlashRead();
         if (result == returnvalue::OK) {
-          triggerEvent(MPSOC_FLASH_READ_SUCCESSFUL, sequenceCount->get());
+          triggerEvent(MPSOC_FLASH_READ_SUCCESSFUL, txSequenceCount.get());
         } else {
-          triggerEvent(MPSOC_FLASH_READ_FAILED, sequenceCount->get());
+          sif::printWarning("PLOC MPSoC Helper: Flash read failed with code %04x\n", result);
+          triggerEvent(MPSOC_FLASH_READ_FAILED, txSequenceCount.get(), result);
         }
         internalState = InternalState::IDLE;
         break;
@@ -72,19 +78,12 @@ ReturnValue_t PlocMpsocSpecialComHelper::performOperation(uint8_t operationCode)
   }
 }
 
-ReturnValue_t PlocMpsocSpecialComHelper::setComIF(DeviceCommunicationIF* communicationInterface_) {
-  uartComIF = dynamic_cast<SerialComIF*>(communicationInterface_);
-  if (uartComIF == nullptr) {
-    sif::warning << "PlocMPSoCHelper::initialize: Invalid uart com if" << std::endl;
-    return returnvalue::FAILED;
-  }
-  return returnvalue::OK;
+void PlocMpsocSpecialComHelper::setCommandSequenceCount(uint16_t sequenceCount_) {
+  txSequenceCount.set(sequenceCount_);
 }
 
-void PlocMpsocSpecialComHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; }
-
-void PlocMpsocSpecialComHelper::setSequenceCount(SourceSequenceCounter* sequenceCount_) {
-  sequenceCount = sequenceCount_;
+uint16_t PlocMpsocSpecialComHelper::getCommandSequenceCount() const {
+  return txSequenceCount.get();
 }
 
 ReturnValue_t PlocMpsocSpecialComHelper::startFlashWrite(std::string obcFile,
@@ -117,7 +116,8 @@ ReturnValue_t PlocMpsocSpecialComHelper::startFlashRead(std::string obcFile, std
 void PlocMpsocSpecialComHelper::resetHelper() {
   spParams.buf = commandBuffer;
   terminate = false;
-  uartComIF->flushUartRxBuffer(comCookie);
+  auto& helper = comInterface.getComHelper();
+  helper.flushUartRxBuffer();
 }
 
 void PlocMpsocSpecialComHelper::stopProcess() { terminate = true; }
@@ -155,7 +155,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashWrite() {
     file.read(reinterpret_cast<char*>(fileBuf.data()), dataLength);
     bytesRead += dataLength;
     remainingSize -= dataLength;
-    mpsoc::TcFlashWrite tc(spParams, *sequenceCount);
+    mpsoc::TcFlashWrite tc(spParams, txSequenceCount);
     result = tc.setPayload(fileBuf.data(), dataLength);
     if (result != returnvalue::OK) {
       return result;
@@ -164,7 +164,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashWrite() {
     if (result != returnvalue::OK) {
       return result;
     }
-    (*sequenceCount)++;
+    txSequenceCount.increment();
     result = handlePacketTransmissionNoReply(tc);
     if (result != returnvalue::OK) {
       return result;
@@ -179,8 +179,12 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashWrite() {
 
 ReturnValue_t PlocMpsocSpecialComHelper::performFlashRead() {
   std::error_code e;
-  std::ofstream ofile(flashReadAndWrite.obcFile, std::ios::trunc | std::ios::binary);
-  if (ofile.bad()) {
+  if (std::filesystem::exists(flashReadAndWrite.obcFile)) {
+    // Truncate the file first.
+    std::ofstream ofile(flashReadAndWrite.obcFile, std::ios::binary | std::ios::trunc);
+  }
+  std::ofstream ofile(flashReadAndWrite.obcFile, std::ios::binary | std::ios::app);
+  if (ofile.bad() or not ofile.is_open()) {
     return returnvalue::FAILED;
   }
   ReturnValue_t result = flashfopen(mpsoc::FileAccessModes::READ);
@@ -203,7 +207,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashRead() {
       std::filesystem::remove(flashReadAndWrite.obcFile, e);
       return FILE_READ_ERROR;
     }
-    mpsoc::TcFlashRead flashReadRequest(spParams, *sequenceCount);
+    mpsoc::TcFlashRead flashReadRequest(spParams, txSequenceCount);
     result = flashReadRequest.setPayload(nextReadSize);
     if (result != returnvalue::OK) {
       std::filesystem::remove(flashReadAndWrite.obcFile, e);
@@ -214,7 +218,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashRead() {
       std::filesystem::remove(flashReadAndWrite.obcFile, e);
       return result;
     }
-    (*sequenceCount)++;
+    txSequenceCount.increment();
     result = handlePacketTransmissionFlashRead(flashReadRequest, ofile, nextReadSize);
     if (result != returnvalue::OK) {
       std::filesystem::remove(flashReadAndWrite.obcFile, e);
@@ -231,7 +235,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashRead() {
 
 ReturnValue_t PlocMpsocSpecialComHelper::flashfopen(uint8_t mode) {
   spParams.buf = commandBuffer;
-  mpsoc::FlashFopen flashFopen(spParams, *sequenceCount);
+  mpsoc::TcFlashFopen flashFopen(spParams, txSequenceCount);
   ReturnValue_t result = flashFopen.setPayload(flashReadAndWrite.mpsocFile, mode);
   if (result != returnvalue::OK) {
     return result;
@@ -240,7 +244,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::flashfopen(uint8_t mode) {
   if (result != returnvalue::OK) {
     return result;
   }
-  (*sequenceCount)++;
+  txSequenceCount.increment();
   result = handlePacketTransmissionNoReply(flashFopen);
   if (result != returnvalue::OK) {
     return result;
@@ -250,12 +254,12 @@ ReturnValue_t PlocMpsocSpecialComHelper::flashfopen(uint8_t mode) {
 
 ReturnValue_t PlocMpsocSpecialComHelper::flashfclose() {
   spParams.buf = commandBuffer;
-  mpsoc::FlashFclose flashFclose(spParams, *sequenceCount);
+  mpsoc::TcFlashFclose flashFclose(spParams, txSequenceCount);
   ReturnValue_t result = flashFclose.finishPacket();
   if (result != returnvalue::OK) {
     return result;
   }
-  (*sequenceCount)++;
+  txSequenceCount.increment();
   result = handlePacketTransmissionNoReply(flashFclose);
   if (result != returnvalue::OK) {
     return result;
@@ -278,6 +282,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::handlePacketTransmissionFlashRead(mpsoc
   if (result != returnvalue::OK) {
     return result;
   }
+  auto& spReader = comInterface.getSpReader();
 
   // We have the nominal case where the flash read report appears first, or the case where we
   // get an EXE failure immediately.
@@ -288,7 +293,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::handlePacketTransmissionFlashRead(mpsoc
     }
     return handleExe();
   } else if (spReader.getApid() == mpsoc::apid::EXE_FAILURE) {
-    handleExeFailure();
+    handleExeFailure(spReader);
   } else {
     triggerEvent(MPSOC_EXE_INVALID_APID, spReader.getApid(), static_cast<uint32_t>(internalState));
     sif::warning << "PLOC MPSoC: Expected execution report "
@@ -311,8 +316,8 @@ ReturnValue_t PlocMpsocSpecialComHelper::handlePacketTransmissionNoReply(ploc::S
 }
 
 ReturnValue_t PlocMpsocSpecialComHelper::sendCommand(ploc::SpTcBase& tc) {
-  ReturnValue_t result = returnvalue::OK;
-  result = uartComIF->sendMessage(comCookie, tc.getFullPacket(), tc.getFullPacketLen());
+  ReturnValue_t result = comInterface.send(tc.getFullPacket(), tc.getFullPacketLen());
+  mpsoc::printTxPacket(tc);
   if (result != returnvalue::OK) {
     sif::warning << "PlocMPSoCHelper::sendCommand: Failed to send command" << std::endl;
     triggerEvent(MPSOC_SENDING_COMMAND_FAILED, result, static_cast<uint32_t>(internalState));
@@ -331,6 +336,8 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleAck() {
   if (result != returnvalue::OK) {
     return result;
   }
+  const auto& spReader = comInterface.getSpReader();
+
   uint16_t apid = spReader.getApid();
   if (apid != mpsoc::apid::ACK_SUCCESS) {
     handleAckApidFailure(spReader);
@@ -339,7 +346,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleAck() {
   return returnvalue::OK;
 }
 
-void PlocMpsocSpecialComHelper::handleAckApidFailure(const ploc::SpTmReader& reader) {
+void PlocMpsocSpecialComHelper::handleAckApidFailure(const SpacePacketReader& reader) {
   uint16_t apid = reader.getApid();
   if (apid == mpsoc::apid::ACK_FAILURE) {
     uint16_t status = mpsoc::getStatusFromRawData(reader.getFullData());
@@ -363,9 +370,10 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleExe() {
   if (result != returnvalue::OK) {
     return result;
   }
+  const auto& spReader = comInterface.getSpReader();
   uint16_t apid = spReader.getApid();
   if (apid == mpsoc::apid::EXE_FAILURE) {
-    handleExeFailure();
+    handleExeFailure(spReader);
     return returnvalue::FAILED;
   } else if (apid != mpsoc::apid::EXE_SUCCESS) {
     triggerEvent(MPSOC_EXE_INVALID_APID, apid, static_cast<uint32_t>(internalState));
@@ -375,7 +383,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleExe() {
   return returnvalue::OK;
 }
 
-void PlocMpsocSpecialComHelper::handleExeFailure() {
+void PlocMpsocSpecialComHelper::handleExeFailure(const SpacePacketReader& spReader) {
   uint16_t status = mpsoc::getStatusFromRawData(spReader.getFullData());
   sif::warning << "PLOC MPSoC EXE Failure: " << mpsoc::getStatusString(status) << std::endl;
   triggerEvent(MPSOC_EXE_FAILURE_REPORT, static_cast<uint32_t>(internalState));
@@ -384,46 +392,32 @@ void PlocMpsocSpecialComHelper::handleExeFailure() {
 ReturnValue_t PlocMpsocSpecialComHelper::handleTmReception() {
   ReturnValue_t result = returnvalue::OK;
   tmCountdown.resetTimer();
-  size_t readBytes = 0;
-  size_t currentBytes = 0;
   uint32_t usleepDelay = 5;
-  size_t fullPacketLen = 0;
   while (true) {
     if (tmCountdown.hasTimedOut()) {
       triggerEvent(MPSOC_READ_TIMEOUT, tmCountdown.getTimeoutMs());
       return returnvalue::FAILED;
     }
-    result = receive(tmBuf.data() + readBytes, 6, &currentBytes);
+    result = tryReceiveNextReply();
+    if (result == MpsocCommunication::PACKET_RECEIVED) {
+      // Need to convert this, we are faking a synchronous API here.
+      result = returnvalue::OK;
+      break;
+    }
     if (result != returnvalue::OK) {
+      if (result == MpsocCommunication::FAULTY_PACKET_SIZE) {
+        sif::printWarning("PLOC MPSoC Helper: retrieving next reply failed: faulty packet size\n");
+      } else if (result == MpsocCommunication::CRC_CHECK_FAILED) {
+        sif::printWarning("PLOC MPSoC Helper: retrieving next reply failed: CRC check failed\n");
+      }
+      sif::printWarning("PLOC MPSoC Helper: retrieving next reply failed with code %d\n", result);
       return result;
     }
-    spReader.setReadOnlyData(tmBuf.data(), tmBuf.size());
-    fullPacketLen = spReader.getFullPacketLen();
-    readBytes += currentBytes;
-    if (readBytes == 6) {
-      break;
-    }
     usleep(usleepDelay);
     if (usleepDelay < 200000) {
       usleepDelay *= 4;
     }
   }
-  while (true) {
-    if (tmCountdown.hasTimedOut()) {
-      triggerEvent(MPSOC_READ_TIMEOUT, tmCountdown.getTimeoutMs());
-      return returnvalue::FAILED;
-    }
-    result = receive(tmBuf.data() + readBytes, fullPacketLen - readBytes, &currentBytes);
-    readBytes += currentBytes;
-    if (fullPacketLen == readBytes) {
-      break;
-    }
-    usleep(usleepDelay);
-    if (usleepDelay < 200000) {
-      usleepDelay *= 4;
-    }
-  }
-  // arrayprinter::print(tmBuf.data(), readBytes);
   return result;
 }
 
@@ -433,6 +427,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleFlashReadReply(std::ofstream& ofi
   if (result != returnvalue::OK) {
     return result;
   }
+  auto& spReader = comInterface.getSpReader();
   uint16_t apid = spReader.getApid();
   if (apid != mpsoc::apid::TM_FLASH_READ_REPORT) {
     triggerEvent(MPSOC_FLASH_READ_PACKET_ERROR, FlashReadErrorType::FLASH_READ_APID_ERROR);
@@ -498,47 +493,25 @@ ReturnValue_t PlocMpsocSpecialComHelper::startFlashReadOrWriteBase(std::string o
 }
 
 ReturnValue_t PlocMpsocSpecialComHelper::checkReceivedTm() {
+  const auto& spReader = comInterface.getSpReader();
   ReturnValue_t result = spReader.checkSize();
   if (result != returnvalue::OK) {
     sif::error << "PLOC MPSoC: Size check on received TM failed" << std::endl;
     triggerEvent(MPSOC_TM_SIZE_ERROR);
     return result;
   }
-  result = spReader.checkCrc();
-  if (result != returnvalue::OK) {
-    sif::warning << "PLOC MPSoC: CRC check failed" << std::endl;
-    triggerEvent(MPSOC_TM_CRC_MISSMATCH, *sequenceCount);
-    return result;
-  }
-  uint16_t recvSeqCnt = spReader.getSequenceCount();
-  if (recvSeqCnt != *sequenceCount) {
-    triggerEvent(MPSOC_HELPER_SEQ_CNT_MISMATCH, *sequenceCount, recvSeqCnt);
-    *sequenceCount = recvSeqCnt;
-  }
-  // This sequence count ping pong does not make any sense but it is how the MPSoC expects it.
-  (*sequenceCount)++;
+  rxSequenceCount = spReader.getSequenceCount();
+  mpsoc::printRxPacket(spReader);
   return returnvalue::OK;
 }
 
-ReturnValue_t PlocMpsocSpecialComHelper::receive(uint8_t* data, size_t requestBytes,
-                                                 size_t* readBytes) {
+ReturnValue_t PlocMpsocSpecialComHelper::tryReceiveNextReply() {
   ReturnValue_t result = returnvalue::OK;
-  uint8_t* buffer = nullptr;
-  result = uartComIF->requestReceiveMessage(comCookie, requestBytes);
+  result = comInterface.readSerialInterface();
   if (result != returnvalue::OK) {
-    sif::warning << "PlocMPSoCHelper::receive: Failed to request reply" << std::endl;
     triggerEvent(MPSOC_HELPER_REQUESTING_REPLY_FAILED, result,
                  static_cast<uint32_t>(static_cast<uint32_t>(internalState)));
     return returnvalue::FAILED;
   }
-  result = uartComIF->readReceivedMessage(comCookie, &buffer, readBytes);
-  if (result != returnvalue::OK) {
-    sif::warning << "PlocMPSoCHelper::receive: Failed to read received message" << std::endl;
-    triggerEvent(MPSOC_HELPER_READING_REPLY_FAILED, result, static_cast<uint32_t>(internalState));
-    return returnvalue::FAILED;
-  }
-  if (*readBytes > 0) {
-    std::memcpy(data, buffer, *readBytes);
-  }
-  return result;
+  return comInterface.parseAndRetrieveNextPacket();
 }

linux/payload/PlocMpsocSpecialComHelper.h

@@ -6,14 +6,13 @@
 
 #include <string>
 
-#include "OBSWConfig.h"
-#include "fsfw/devicehandlers/CookieIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/osal/linux/BinarySemaphore.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
+#include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
 #include "fsfw/tmtcservices/SourceSequenceCounter.h"
-#include "fsfw_hal/linux/serial/SerialComIF.h"
+#include "linux/payload/MpsocCommunication.h"
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/SdCardManager.h"
 #endif
@@ -83,15 +82,12 @@ class PlocMpsocSpecialComHelper : public SystemObject, public ExecutableObjectIF
     FLASH_READ_READLEN_ERROR = 2
   };
 
-  PlocMpsocSpecialComHelper(object_id_t objectId);
+  PlocMpsocSpecialComHelper(object_id_t objectId, MpsocCommunication& comInterface);
   virtual ~PlocMpsocSpecialComHelper();
 
   ReturnValue_t initialize() override;
   ReturnValue_t performOperation(uint8_t operationCode = 0) override;
 
-  ReturnValue_t setComIF(DeviceCommunicationIF* communicationInterface_);
-  void setComCookie(CookieIF* comCookie_);
-
   /**
    * @brief   Starts flash write sequence
    *
@@ -118,7 +114,8 @@ class PlocMpsocSpecialComHelper : public SystemObject, public ExecutableObjectIF
   /**
    * @brief   Sets the sequence count object responsible for the sequence count handling
    */
-  void setSequenceCount(SourceSequenceCounter* sequenceCount_);
+  void setCommandSequenceCount(uint16_t sequenceCount_);
+  uint16_t getCommandSequenceCount() const;
 
  private:
   static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MPSOC_HELPER;
@@ -169,12 +166,14 @@ class PlocMpsocSpecialComHelper : public SystemObject, public ExecutableObjectIF
    * Communication interface of MPSoC responsible for low level access. Must be set by the
    * MPSoC Handler.
    */
-  SerialComIF* uartComIF = nullptr;
+  // SerialComIF* uartComIF = nullptr;
   // Communication cookie. Must be set by the MPSoC Handler
-  CookieIF* comCookie = nullptr;
+  // CookieIF* comCookie = nullptr;
+  MpsocCommunication& comInterface;
   // Sequence count, must be set by Ploc MPSoC Handler
-  SourceSequenceCounter* sequenceCount = nullptr;
-  ploc::SpTmReader spReader;
+  // ploc::SpTmReader spReader;
+  uint16_t rxSequenceCount = 0;
+  SourceSequenceCounter txSequenceCount = 0;
 
   void resetHelper();
   ReturnValue_t performFlashWrite();
@@ -186,13 +185,13 @@ class PlocMpsocSpecialComHelper : public SystemObject, public ExecutableObjectIF
                                                   size_t expectedReadLen);
   ReturnValue_t handleFlashReadReply(std::ofstream& ofile, size_t expectedReadLen);
   ReturnValue_t sendCommand(ploc::SpTcBase& tc);
-  ReturnValue_t receive(uint8_t* data, size_t requestBytes, size_t* readBytes);
+  ReturnValue_t tryReceiveNextReply();
   ReturnValue_t handleAck();
   ReturnValue_t handleExe();
   ReturnValue_t startFlashReadOrWriteBase(std::string obcFile, std::string mpsocFile);
   ReturnValue_t fileCheck(std::string obcFile);
-  void handleAckApidFailure(const ploc::SpTmReader& reader);
-  void handleExeFailure();
+  void handleAckApidFailure(const SpacePacketReader& reader);
+  void handleExeFailure(const SpacePacketReader& reader);
   ReturnValue_t handleTmReception();
   ReturnValue_t checkReceivedTm();
 };

linux/payload/PlocSupvUartMan.cpp

@@ -437,6 +437,8 @@ ReturnValue_t PlocSupvUartManager::writeUpdatePackets() {
         // Useful to allow restarting the update
         triggerEvent(SUPV_UPDATE_PROGRESS, buildProgParams1(progPercent, update.sequenceCount),
                      update.bytesWritten);
+        sif::info << "PLOC SUPV update progress " << (int)progPercent << " % at "
+                  << update.bytesWritten << " bytes" << std::endl;
       }
     }
     supv::WriteMemory packet(spParams);

linux/payload/SerialCommunicationHelper.cpp

@@ -0,0 +1,126 @@
+#include "SerialCommunicationHelper.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <termios.h>
+#include <unistd.h>
+
+#include <cstring>
+
+#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw_hal/linux/serial/helper.h"
+
+SerialCommunicationHelper::SerialCommunicationHelper(SerialConfig cfg) : cfg(cfg) {}
+
+ReturnValue_t SerialCommunicationHelper::initialize() {
+  fd = configureUartPort();
+  if (fd < 0) {
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}
+
+int SerialCommunicationHelper::rawFd() const { return fd; }
+
+ReturnValue_t SerialCommunicationHelper::send(const uint8_t* data, size_t dataLen) {
+  if (write(fd, data, dataLen) != static_cast<int>(dataLen)) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "UartComIF::sendMessage: Failed to send data with error code " << errno
+               << ": Error description: " << strerror(errno) << std::endl;
+#endif
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}
+
+int SerialCommunicationHelper::configureUartPort() {
+  struct termios options = {};
+
+  int flags = O_RDWR;
+  if (cfg.getUartMode() == UartModes::CANONICAL) {
+    // In non-canonical mode, don't specify O_NONBLOCK because these properties will be
+    // controlled by the VTIME and VMIN parameters and O_NONBLOCK would override this
+    flags |= O_NONBLOCK;
+  }
+  int fd = open(cfg.getDeviceFile().c_str(), flags);
+
+  if (fd < 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UartComIF::configureUartPort: Failed to open uart "
+                 << cfg.getDeviceFile().c_str()
+
+                 << "with error code " << errno << strerror(errno) << std::endl;
+#endif
+    return fd;
+  }
+
+  /* Read in existing settings */
+  if (tcgetattr(fd, &options) != 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UartComIF::configureUartPort: Error " << errno
+                 << "from tcgetattr: " << strerror(errno) << std::endl;
+#endif
+    return fd;
+  }
+
+  serial::setParity(options, cfg.getParity());
+  serial::setStopbits(options, cfg.getStopBits());
+  serial::setBitsPerWord(options, cfg.getBitsPerWord());
+  setFixedOptions(&options);
+  serial::setMode(options, cfg.getUartMode());
+  tcflush(fd, TCIFLUSH);
+
+  /* Sets uart to non-blocking mode. Read returns immediately when there are no data available */
+  options.c_cc[VTIME] = 0;
+  options.c_cc[VMIN] = 0;
+
+  serial::setBaudrate(options, cfg.getBaudrate());
+
+  /* Save option settings */
+  if (tcsetattr(fd, TCSANOW, &options) != 0) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "UartComIF::configureUartPort: Failed to set options with error " << errno
+                 << ": " << strerror(errno);
+#endif
+    return fd;
+  }
+  return fd;
+}
+
+void SerialCommunicationHelper::setFixedOptions(struct termios* options) {
+  /* Disable RTS/CTS hardware flow control */
+  options->c_cflag &= ~CRTSCTS;
+  /* Turn on READ & ignore ctrl lines (CLOCAL = 1) */
+  options->c_cflag |= CREAD | CLOCAL;
+  /* Disable echo */
+  options->c_lflag &= ~ECHO;
+  /* Disable erasure */
+  options->c_lflag &= ~ECHOE;
+  /* Disable new-line echo */
+  options->c_lflag &= ~ECHONL;
+  /* Disable interpretation of INTR, QUIT and SUSP */
+  options->c_lflag &= ~ISIG;
+  /* Turn off s/w flow ctrl */
+  options->c_iflag &= ~(IXON | IXOFF | IXANY);
+  /* Disable any special handling of received bytes */
+  options->c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL);
+  /* Prevent special interpretation of output bytes (e.g. newline chars) */
+  options->c_oflag &= ~OPOST;
+  /* Prevent conversion of newline to carriage return/line feed */
+  options->c_oflag &= ~ONLCR;
+}
+
+ReturnValue_t SerialCommunicationHelper::flushUartRxBuffer() {
+  serial::flushRxBuf(fd);
+  return returnvalue::OK;
+}
+
+ReturnValue_t SerialCommunicationHelper::flushUartTxBuffer() {
+  serial::flushTxBuf(fd);
+  return returnvalue::OK;
+}
+
+ReturnValue_t SerialCommunicationHelper::flushUartTxAndRxBuf() {
+  serial::flushTxRxBuf(fd);
+  return returnvalue::OK;
+}

linux/payload/SerialCommunicationHelper.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw_hal/linux/serial/SerialCookie.h>
+#include <fsfw_hal/linux/serial/helper.h>
+
+#include "SerialConfig.h"
+#include "fsfw/returnvalues/returnvalue.h"
+
+/**
+ * @brief 	This is the communication interface to access serial ports on linux based operating
+ *          systems.
+ *
+ * @details The implementation follows the instructions from https://blog.mbedded.ninja/programming/
+ *          operating-systems/linux/linux-serial-ports-using-c-cpp/#disabling-canonical-mode
+ *
+ * @author 	J. Meier
+ */
+class SerialCommunicationHelper {
+ public:
+  SerialCommunicationHelper(SerialConfig serialCfg);
+
+  ReturnValue_t send(const uint8_t* data, size_t dataLen);
+
+  int rawFd() const;
+
+  ReturnValue_t initialize();
+
+  /**
+   * @brief   This function discards all data received but not read in the UART buffer.
+   */
+  ReturnValue_t flushUartRxBuffer();
+
+  /**
+   * @brief   This function discards all data in the transmit buffer of the UART driver.
+   */
+  ReturnValue_t flushUartTxBuffer();
+
+  /**
+   * @brief   This function discards both data in the transmit and receive buffer of the UART.
+   */
+  ReturnValue_t flushUartTxAndRxBuf();
+
+ private:
+  SerialConfig cfg;
+  int fd = 0;
+
+  /**
+   * @brief	This function opens and configures a uart device by using the information stored
+   *          in the uart cookie.
+   * @param uartCookie    Pointer to uart cookie with information about the uart. Contains the
+   *                      uart device file, baudrate, parity, stopbits etc.
+   * @return  The file descriptor of the configured uart.
+   */
+  int configureUartPort();
+
+  void setStopBitOptions(struct termios* options);
+
+  /**
+   * @brief   This function sets options which are not configurable by the uartCookie.
+   */
+  void setFixedOptions(struct termios* options);
+
+  /**
+   * @brief   With this function the datasize settings are added to the termios options struct.
+   */
+  void setDatasizeOptions(struct termios* options);
+};

linux/payload/SerialConfig.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <fsfw/devicehandlers/CookieIF.h>
+#include <fsfw/objectmanager/SystemObjectIF.h>
+#include <fsfw_hal/linux/serial/helper.h>
+
+#include <string>
+
+/**
+ * @brief   Cookie for the UartComIF. There are many options available to configure the UART driver.
+ *          The constructor only requests for common options like the baudrate. Other options can
+ *          be set by member functions.
+ *
+ * @author 	J. Meier
+ */
+class SerialConfig : public CookieIF {
+ public:
+  /**
+   * @brief	Constructor for the uart cookie.
+   * @param deviceFile    The device file specifying the uart to use, e.g. "/dev/ttyPS1"
+   * @param uartMode      Specify the UART mode. The canonical mode should be used if the
+   *                      messages are separated by a delimited character like '\n'. See the
+   *                      termios documentation for more information
+   * @param baudrate      The baudrate to use for input and output.
+   * @param maxReplyLen   The maximum size an object using this cookie expects
+   * @details
+   * Default configuration: No parity
+   *                        8 databits (number of bits transfered with one uart frame)
+   *                        One stop bit
+   */
+  SerialConfig(std::string deviceFile, UartBaudRate baudrate, size_t maxReplyLen,
+               UartModes uartMode = UartModes::NON_CANONICAL)
+      : deviceFile(deviceFile), baudrate(baudrate), maxReplyLen(maxReplyLen), uartMode(uartMode) {}
+
+  virtual ~SerialConfig() = default;
+
+  UartBaudRate getBaudrate() const { return baudrate; }
+  size_t getMaxReplyLen() const { return maxReplyLen; }
+  std::string getDeviceFile() const { return deviceFile; }
+  Parity getParity() const { return parity; }
+  BitsPerWord getBitsPerWord() const { return bitsPerWord; }
+  StopBits getStopBits() const { return stopBits; }
+  UartModes getUartMode() const { return uartMode; }
+
+  /**
+   * Functions two enable parity checking.
+   */
+  void setParityOdd() { parity = Parity::ODD; }
+  void setParityEven() { parity = Parity::EVEN; }
+
+  /**
+   * Function two set number of bits per UART frame.
+   */
+  void setBitsPerWord(BitsPerWord bitsPerWord_) { bitsPerWord = bitsPerWord_; }
+
+  /**
+   * Function to specify the number of stopbits.
+   */
+  void setTwoStopBits() { stopBits = StopBits::TWO_STOP_BITS; }
+  void setOneStopBit() { stopBits = StopBits::ONE_STOP_BIT; }
+
+ private:
+  std::string deviceFile;
+  UartBaudRate baudrate;
+  size_t maxReplyLen = 0;
+  const UartModes uartMode;
+  Parity parity = Parity::NONE;
+  BitsPerWord bitsPerWord = BitsPerWord::BITS_8;
+  StopBits stopBits = StopBits::ONE_STOP_BIT;
+};

linux/payload/mpsocRetvals.h

@@ -1,33 +0,0 @@
-#ifndef MPSOC_RETURN_VALUES_IF_H_
-#define MPSOC_RETURN_VALUES_IF_H_
-
-#include "eive/resultClassIds.h"
-#include "fsfw/returnvalues/returnvalue.h"
-
-class MPSoCReturnValuesIF {
- public:
-  static const uint8_t INTERFACE_ID = CLASS_ID::MPSOC_RETURN_VALUES_IF;
-
-  //! [EXPORT] : [COMMENT] Space Packet received from PLOC has invalid CRC
-  static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0);
-  //! [EXPORT] : [COMMENT] Received ACK failure reply from PLOC
-  static const ReturnValue_t RECEIVED_ACK_FAILURE = MAKE_RETURN_CODE(0xA1);
-  //! [EXPORT] : [COMMENT] Received execution failure reply from PLOC
-  static const ReturnValue_t RECEIVED_EXE_FAILURE = MAKE_RETURN_CODE(0xA2);
-  //! [EXPORT] : [COMMENT] Received space packet with invalid APID from PLOC
-  static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3);
-  //! [EXPORT] : [COMMENT] Received command with invalid length
-  static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xA4);
-  //! [EXPORT] : [COMMENT] Filename of file in OBC filesystem is too long
-  static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA5);
-  //! [EXPORT] : [COMMENT] MPSoC helper is currently executing a command
-  static const ReturnValue_t MPSOC_HELPER_EXECUTING = MAKE_RETURN_CODE(0xA6);
-  //! [EXPORT] : [COMMENT] Filename of MPSoC file is to long (max. 256 bytes)
-  static const ReturnValue_t MPSOC_FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA7);
-  //! [EXPORT] : [COMMENT] Command has invalid parameter
-  static const ReturnValue_t INVALID_PARAMETER = MAKE_RETURN_CODE(0xA8);
-  //! [EXPORT] : [COMMENT] Received command has file string with invalid length
-  static const ReturnValue_t NAME_TOO_LONG = MAKE_RETURN_CODE(0xA9);
-};
-
-#endif /* MPSOC_RETURN_VALUES_IF_H_ */

linux/payload/plocMpsocHelpers.cpp

@@ -1,87 +1,94 @@
 #include "plocMpsocHelpers.h"
 
+#include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
+#include "mission/payload/plocSpBase.h"
+
 uint16_t mpsoc::getStatusFromRawData(const uint8_t* data) {
   return (*(data + STATUS_OFFSET) << 8) | *(data + STATUS_OFFSET + 1);
 }
 std::string mpsoc::getStatusString(uint16_t status) {
   switch (status) {
-    case (mpsoc::status_code::UNKNOWN_APID): {
+    case (mpsoc::statusCode::UNKNOWN_APID): {
       return "Unknown APID";
       break;
     }
-    case (mpsoc::status_code::INCORRECT_LENGTH): {
+    case (mpsoc::statusCode::INCORRECT_LENGTH): {
       return "Incorrect length";
       break;
     }
-    case (mpsoc::status_code::INCORRECT_CRC): {
+    case (mpsoc::statusCode::FLASH_DRIVE_ERROR): {
+      return "flash drive error";
+      break;
+    }
+    case (mpsoc::statusCode::INCORRECT_CRC): {
       return "Incorrect crc";
       break;
     }
-    case (mpsoc::status_code::INCORRECT_PKT_SEQ_CNT): {
+    case (mpsoc::statusCode::INCORRECT_PKT_SEQ_CNT): {
       return "Incorrect packet sequence count";
       break;
     }
-    case (mpsoc::status_code::TC_NOT_ALLOWED_IN_MODE): {
+    case (mpsoc::statusCode::TC_NOT_ALLOWED_IN_MODE): {
       return "TC not allowed in this mode";
       break;
     }
-    case (mpsoc::status_code::TC_EXEUTION_DISABLED): {
+    case (mpsoc::statusCode::TC_EXEUTION_DISABLED): {
       return "TC execution disabled";
       break;
     }
-    case (mpsoc::status_code::FLASH_MOUNT_FAILED): {
+    case (mpsoc::statusCode::FLASH_MOUNT_FAILED): {
       return "Flash mount failed";
       break;
     }
-    case (mpsoc::status_code::FLASH_FILE_ALREADY_OPEN): {
+    case (mpsoc::statusCode::FLASH_FILE_ALREADY_OPEN): {
       return "Flash file already open";
       break;
     }
-    case (mpsoc::status_code::FLASH_FILE_ALREADY_CLOSED): {
+    case (mpsoc::statusCode::FLASH_FILE_ALREADY_CLOSED): {
       return "Flash file already closed";
       break;
     }
-    case (mpsoc::status_code::FLASH_FILE_OPEN_FAILED): {
+    case (mpsoc::statusCode::FLASH_FILE_OPEN_FAILED): {
       return "Flash file open failed";
       break;
     }
-    case (mpsoc::status_code::FLASH_FILE_NOT_OPEN): {
+    case (mpsoc::statusCode::FLASH_FILE_NOT_OPEN): {
       return "Flash file not open";
       break;
     }
-    case (mpsoc::status_code::FLASH_UNMOUNT_FAILED): {
+    case (mpsoc::statusCode::FLASH_UNMOUNT_FAILED): {
       return "Flash unmount failed";
       break;
     }
-    case (mpsoc::status_code::HEAP_ALLOCATION_FAILED): {
+    case (mpsoc::statusCode::HEAP_ALLOCATION_FAILED): {
       return "Heap allocation failed";
       break;
     }
-    case (mpsoc::status_code::INVALID_PARAMETER): {
+    case (mpsoc::statusCode::INVALID_PARAMETER): {
       return "Invalid parameter";
       break;
     }
-    case (mpsoc::status_code::NOT_INITIALIZED): {
+    case (mpsoc::statusCode::NOT_INITIALIZED): {
       return "Not initialized";
       break;
     }
-    case (mpsoc::status_code::REBOOT_IMMINENT): {
+    case (mpsoc::statusCode::REBOOT_IMMINENT): {
       return "Reboot imminent";
       break;
     }
-    case (mpsoc::status_code::CORRUPT_DATA): {
+    case (mpsoc::statusCode::CORRUPT_DATA): {
       return "Corrupt data";
       break;
     }
-    case (mpsoc::status_code::FLASH_CORRECTABLE_MISMATCH): {
+    case (mpsoc::statusCode::FLASH_CORRECTABLE_MISMATCH): {
       return "Flash correctable mismatch";
       break;
     }
-    case (mpsoc::status_code::FLASH_UNCORRECTABLE_MISMATCH): {
+    case (mpsoc::statusCode::FLASH_UNCORRECTABLE_MISMATCH): {
       return "Flash uncorrectable mismatch";
       break;
     }
-    case (mpsoc::status_code::DEFAULT_ERROR_CODE): {
+    case (mpsoc::statusCode::DEFAULT_ERROR_CODE): {
       return "Default error code";
       break;
     }
@@ -93,3 +100,19 @@ std::string mpsoc::getStatusString(uint16_t status) {
   }
   return "";
 }
+
+void mpsoc::printRxPacket(const SpacePacketReader& spReader) {
+  if (mpsoc::MPSOC_RX_WIRETAPPING) {
+    sif::debug << "RECV MPSOC packet. APID 0x" << std::hex << std::setw(3) << spReader.getApid()
+               << std::dec << " Size " << spReader.getFullPacketLen() << " SSC "
+               << spReader.getSequenceCount() << std::endl;
+  }
+}
+
+void mpsoc::printTxPacket(const ploc::SpTcBase& tcBase) {
+  if (mpsoc::MPSOC_TX_WIRETAPPING) {
+    sif::debug << "SEND MPSOC packet. APID 0x" << std::hex << std::setw(3) << tcBase.getApid()
+               << " Size " << std::dec << tcBase.getFullPacketLen() << " SSC "
+               << tcBase.getSeqCount() << std::endl;
+  }
+}

linux/payload/plocMpsocHelpers.h

@@ -3,16 +3,122 @@
 
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
-#include <linux/payload/mpsocRetvals.h>
 #include <mission/payload/plocSpBase.h>
 
-#include "OBSWConfig.h"
-#include "eive/definitions.h"
-#include "fsfw/globalfunctions/CRC.h"
+#include "eive/eventSubsystemIds.h"
+#include "eive/resultClassIds.h"
+#include "fsfw/action/HasActionsIF.h"
+#include "fsfw/events/Event.h"
+#include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/serialize/SerializeAdapter.h"
+#include "fsfw/serialize/SerializeIF.h"
 
 namespace mpsoc {
 
+static constexpr bool MPSOC_TX_WIRETAPPING = false;
+static constexpr bool MPSOC_RX_WIRETAPPING = false;
+
+static constexpr size_t CRC_SIZE = 2;
+
+/**
+ * @brief   Abstract base class for TC space packet of MPSoC.
+ */
+class TcBase : public ploc::SpTcBase {
+ public:
+  virtual ~TcBase() = default;
+
+  // Initial length field of space packet. Will always be updated when packet is created.
+  static const uint16_t INIT_LENGTH = CRC_SIZE;
+
+  /**
+   * @brief    Constructor
+   *
+   * @param sequenceCount Sequence count of space packet which will be incremented with each
+   *        sent and received packets.
+   */
+  TcBase(ploc::SpTcParams params, uint16_t apid, uint16_t sequenceCount)
+      : ploc::SpTcBase(params, apid, 0, sequenceCount) {
+    payloadStart = spParams.buf + ccsds::HEADER_LEN;
+    spParams.setFullPayloadLen(INIT_LENGTH);
+  }
+
+  /**
+   * @brief   Function to finsh and write the space packet. It is expected that the user has
+   * set the payload fields in the child class*
+   * @return  returnvalue::OK if packet creation was successful, otherwise error return value
+   */
+  ReturnValue_t finishPacket() {
+    updateSpFields();
+    ReturnValue_t res = checkSizeAndSerializeHeader();
+    if (res != returnvalue::OK) {
+      return res;
+    }
+    return calcAndSetCrc();
+  }
+};
+
+void printRxPacket(const SpacePacketReader& spReader);
+void printTxPacket(const ploc::SpTcBase& tcBase);
+
+static constexpr uint32_t DEFAULT_CMD_TIMEOUT_MS = 5000;
+static constexpr uint32_t CMD_TIMEOUT_MKFS = 15000;
+
+enum FlashId : uint8_t { FLASH_0 = 0, FLASH_1 = 1 };
+
+static const uint8_t INTERFACE_ID = CLASS_ID::MPSOC_RETURN_VALUES_IF;
+
+//! [EXPORT] : [COMMENT] Space Packet received from PLOC has invalid CRC
+static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0);
+//! [EXPORT] : [COMMENT] Received ACK failure reply from PLOC
+static const ReturnValue_t RECEIVED_ACK_FAILURE = MAKE_RETURN_CODE(0xA1);
+//! [EXPORT] : [COMMENT] Received execution failure reply from PLOC
+static const ReturnValue_t RECEIVED_EXE_FAILURE = MAKE_RETURN_CODE(0xA2);
+//! [EXPORT] : [COMMENT] Received space packet with invalid APID from PLOC
+static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3);
+//! [EXPORT] : [COMMENT] Received command with invalid length
+static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xA4);
+//! [EXPORT] : [COMMENT] Filename of file in OBC filesystem is too long
+static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA5);
+//! [EXPORT] : [COMMENT] MPSoC helper is currently executing a command
+static const ReturnValue_t MPSOC_HELPER_EXECUTING = MAKE_RETURN_CODE(0xA6);
+//! [EXPORT] : [COMMENT] Filename of MPSoC file is to long (max. 256 bytes)
+static const ReturnValue_t MPSOC_FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA7);
+//! [EXPORT] : [COMMENT] Command has invalid parameter
+static const ReturnValue_t INVALID_PARAMETER = MAKE_RETURN_CODE(0xA8);
+//! [EXPORT] : [COMMENT] Received command has file string with invalid length
+static const ReturnValue_t NAME_TOO_LONG = MAKE_RETURN_CODE(0xA9);
+//! [EXPORT] : [COMMENT] Command has timed out.
+static const ReturnValue_t COMMAND_TIMEOUT = MAKE_RETURN_CODE(0x10);
+
+static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HANDLER;
+
+//! [EXPORT] : [COMMENT] PLOC crc failure in telemetry packet
+static const Event MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW);
+//! [EXPORT] : [COMMENT] PLOC receive acknowledgment failure report
+//! P1: Command Id which leads the acknowledgment failure report
+//! P2: The status field inserted by the MPSoC into the data field
+static const Event ACK_FAILURE = MAKE_EVENT(2, severity::LOW);
+//! [EXPORT] : [COMMENT] PLOC receive execution failure report
+//! P1: Command Id which leads the execution failure report
+//! P2: The status field inserted by the MPSoC into the data field
+static const Event EXE_FAILURE = MAKE_EVENT(3, severity::LOW);
+//! [EXPORT] : [COMMENT] PLOC reply has invalid crc
+static const Event MPSOC_HANDLER_CRC_FAILURE = MAKE_EVENT(4, severity::LOW);
+//! [EXPORT] : [COMMENT] Packet sequence count in received space packet does not match expected
+//! count P1: Expected sequence count P2: Received sequence count
+static const Event MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH = MAKE_EVENT(5, severity::LOW);
+//! [EXPORT] : [COMMENT] Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and
+//! thus also to shutdown the supervisor.
+static const Event MPSOC_SHUTDOWN_FAILED = MAKE_EVENT(6, severity::HIGH);
+//! [EXPORT] : [COMMENT] SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for
+//! ON transition.
+static constexpr Event SUPV_NOT_ON = event::makeEvent(SUBSYSTEM_ID, 7, severity::LOW);
+//! [EXPORT] : [COMMENT] SUPV reply timeout.
+static constexpr Event SUPV_REPLY_TIMEOUT = event::makeEvent(SUBSYSTEM_ID, 8, severity::LOW);
+//! [EXPORT] : [COMMENT] Camera must be commanded on first.
+static constexpr Event CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE =
+    event::makeEvent(SUBSYSTEM_ID, 9, severity::LOW);
+
 enum ParamId : uint8_t { SKIP_SUPV_ON_COMMANDING = 0x01 };
 
 enum FileAccessModes : uint8_t {
@@ -30,6 +136,8 @@ enum FileAccessModes : uint8_t {
 };
 
 static constexpr uint32_t HK_SET_ID = 0;
+static constexpr uint32_t DEADBEEF_ADDR = 0x40000004;
+static constexpr uint32_t DEADBEEF_VALUE = 0xdeadbeef;
 
 namespace poolid {
 enum {
@@ -92,7 +200,8 @@ static const DeviceCommandId_t TM_CAM_CMD_RPT = 19;
 static const DeviceCommandId_t SET_UART_TX_TRISTATE = 20;
 static const DeviceCommandId_t RELEASE_UART_TX = 21;
 static const DeviceCommandId_t TC_CAM_TAKE_PIC = 22;
-static const DeviceCommandId_t TC_SIMPLEX_SEND_FILE = 23;
+// Stream file down using E-Band component directly.
+static const DeviceCommandId_t TC_SIMPLEX_STREAM_FILE = 23;
 static const DeviceCommandId_t TC_DOWNLINK_DATA_MODULATE = 24;
 static const DeviceCommandId_t TC_MODE_SNAPSHOT = 25;
 static const DeviceCommandId_t TC_GET_HK_REPORT = 26;
@@ -100,16 +209,31 @@ static const DeviceCommandId_t TM_GET_HK_REPORT = 27;
 static const DeviceCommandId_t TC_FLASH_GET_DIRECTORY_CONTENT = 28;
 static const DeviceCommandId_t TM_FLASH_DIRECTORY_CONTENT = 29;
 static constexpr DeviceCommandId_t TC_FLASH_READ_FULL_FILE = 30;
+// Store file on MPSoC.
+static const DeviceCommandId_t TC_SPLIT_FILE = 31;
+static const DeviceCommandId_t TC_VERIFY_BOOT = 32;
+static const DeviceCommandId_t TC_ENABLE_TC_EXECTION = 33;
+static const DeviceCommandId_t TC_FLASH_MKFS = 34;
 
-// Will reset the sequence count of the OBSW
-static const DeviceCommandId_t OBSW_RESET_SEQ_COUNT = 50;
+// Will reset the sequence count of the OBSW. Not required anymore after MPSoC update.
+static const DeviceCommandId_t OBSW_RESET_SEQ_COUNT_LEGACY = 50;
 
 static const uint16_t SIZE_ACK_REPORT = 14;
 static const uint16_t SIZE_EXE_REPORT = 14;
-static const uint16_t SIZE_TM_MEM_READ_REPORT = 18;
-static const uint16_t SIZE_TM_CAM_CMD_RPT = 18;
 static constexpr size_t SIZE_TM_HK_REPORT = 369;
 
+enum Submode : uint8_t { IDLE_OR_NONE = 0, REPLAY = 1, SNAPSHOT = 2 };
+
+// Setting the internal mode value to the actual telecommand ID
+/*
+enum InternalMode {
+  OFF = HasModesIF::MODE_OFF,
+  IDLE = ,
+  REPLAY = TC_MODE_REPLAY,
+  SNAPSHOT = TC_MODE_SNAPSHOT
+};
+*/
+
 /**
  * SpacePacket apids of PLOC telecommands and telemetry.
  */
@@ -134,6 +258,8 @@ static const uint16_t TC_MODE_SNAPSHOT = 0x120;
 static const uint16_t TC_DOWNLINK_DATA_MODULATE = 0x121;
 static constexpr uint16_t TC_HK_GET_REPORT = 0x123;
 static const uint16_t TC_DOWNLINK_PWR_OFF = 0x124;
+static constexpr uint16_t TC_ENABLE_TC_EXECUTION = 0x129;
+static constexpr uint16_t TC_FLASH_MKFS = 0x12A;
 static const uint16_t TC_CAM_CMD_SEND = 0x12C;
 static constexpr uint16_t TC_FLASH_COPY_FILE = 0x12E;
 static const uint16_t TC_SIMPLEX_SEND_FILE = 0x130;
@@ -158,15 +284,15 @@ static const uint8_t SPACE_PACKET_HEADER_SIZE = 6;
 
 static const uint8_t STATUS_OFFSET = 10;
 
-static constexpr size_t CRC_SIZE = 2;
-
 /**
  * The size of payload data which will be forwarded to the requesting object. e.g. PUS Service
  * 8.
  */
 static const uint8_t SIZE_MEM_READ_RPT_FIX = 6;
 
-static const size_t MAX_FILENAME_SIZE = 256;
+static const size_t FILENAME_FIELD_SIZE = 256;
+// Subtract size of NULL terminator.
+static const size_t MAX_FILENAME_SIZE = FILENAME_FIELD_SIZE - 1;
 
 /**
  * PLOC space packet length for fixed size packets. This is the size of the whole packet data
@@ -201,8 +327,9 @@ static const uint16_t TC_DOWNLINK_PWR_ON_EXECUTION_DELAY = 8;
 static const uint16_t TC_CAM_TAKE_PIC_EXECUTION_DELAY = 20;
 static const uint16_t TC_SIMPLEX_SEND_FILE_DELAY = 80;
 
-namespace status_code {
+namespace statusCode {
 static const uint16_t DEFAULT_ERROR_CODE = 0x1;
+static constexpr uint16_t FLASH_DRIVE_ERROR = 0xb;
 static const uint16_t UNKNOWN_APID = 0x5DD;
 static const uint16_t INCORRECT_LENGTH = 0x5DE;
 static const uint16_t INCORRECT_CRC = 0x5DF;
@@ -227,49 +354,12 @@ static const uint16_t RESERVED_1 = 0x5F1;
 static const uint16_t RESERVED_2 = 0x5F2;
 static const uint16_t RESERVED_3 = 0x5F3;
 static const uint16_t RESERVED_4 = 0x5F4;
-}  // namespace status_code
-
-/**
- * @brief   Abstract base class for TC space packet of MPSoC.
- */
-class TcBase : public ploc::SpTcBase, public MPSoCReturnValuesIF {
- public:
-  virtual ~TcBase() = default;
-
-  // Initial length field of space packet. Will always be updated when packet is created.
-  static const uint16_t INIT_LENGTH = CRC_SIZE;
-
-  /**
-   * @brief    Constructor
-   *
-   * @param sequenceCount Sequence count of space packet which will be incremented with each
-   *        sent and received packets.
-   */
-  TcBase(ploc::SpTcParams params, uint16_t apid, uint16_t sequenceCount)
-      : ploc::SpTcBase(params, apid, 0, sequenceCount) {
-    payloadStart = spParams.buf + ccsds::HEADER_LEN;
-    spParams.setFullPayloadLen(INIT_LENGTH);
-  }
-
-  /**
-   * @brief   Function to finsh and write the space packet. It is expected that the user has
-   * set the payload fields in the child class*
-   * @return  returnvalue::OK if packet creation was successful, otherwise error return value
-   */
-  ReturnValue_t finishPacket() {
-    updateSpFields();
-    ReturnValue_t res = checkSizeAndSerializeHeader();
-    if (res != returnvalue::OK) {
-      return res;
-    }
-    return calcAndSetCrc();
-  }
-};
+}  // namespace statusCode
 
 /**
  * @brief   This class helps to build the memory read command for the PLOC.
  */
-class TcMemRead : public TcBase {
+class TcMemRead : public mpsoc::TcBase {
  public:
   /**
    * @brief   Constructor
@@ -319,7 +409,7 @@ class TcMemRead : public TcBase {
  * @brief   This class helps to generate the space packet to write data to a memory address within
  *          the PLOC.
  */
-class TcMemWrite : public TcBase {
+class TcMemWrite : public mpsoc::TcBase {
  public:
   /**
    * @brief   Constructor
@@ -369,24 +459,21 @@ class TcMemWrite : public TcBase {
 /**
  * @brief   Class to help creation of flash fopen command.
  */
-class FlashFopen : public TcBase {
+class TcFlashFopen : public mpsoc::TcBase {
  public:
-  FlashFopen(ploc::SpTcParams params, uint16_t sequenceCount)
+  TcFlashFopen(ploc::SpTcParams params, uint16_t sequenceCount)
       : TcBase(params, apid::TC_FLASHFOPEN, sequenceCount) {}
 
   ReturnValue_t setPayload(std::string filename, uint8_t mode) {
     accessMode = mode;
-    size_t nameSize = filename.size();
-    spParams.setFullPayloadLen(256 + sizeof(uint8_t) + CRC_SIZE);
     ReturnValue_t result = checkPayloadLen();
     if (result != returnvalue::OK) {
       return result;
     }
-    std::memcpy(payloadStart, filename.c_str(), nameSize);
-    // payloadStart[nameSize] = NULL_TERMINATOR;
-    std::memset(payloadStart + nameSize, 0, 256 - nameSize);
-    // payloadStart[255] = NULL_TERMINATOR;
-    payloadStart[256] = accessMode;
+    std::memset(payloadStart, 0, FILENAME_FIELD_SIZE);
+    std::memcpy(payloadStart, filename.c_str(), filename.size());
+    payloadStart[FILENAME_FIELD_SIZE] = accessMode;
+    spParams.setFullPayloadLen(FILENAME_FIELD_SIZE + 1 + CRC_SIZE);
     return returnvalue::OK;
   }
 
@@ -397,14 +484,46 @@ class FlashFopen : public TcBase {
 /**
  * @brief   Class to help creation of flash fclose command.
  */
-class FlashFclose : public TcBase {
+class TcFlashFclose : public TcBase {
  public:
-  FlashFclose(ploc::SpTcParams params, uint16_t sequenceCount)
+  TcFlashFclose(ploc::SpTcParams params, uint16_t sequenceCount)
       : TcBase(params, apid::TC_FLASHFCLOSE, sequenceCount) {
     spParams.setFullPayloadLen(CRC_SIZE);
   }
 };
 
+class TcEnableTcExec : public TcBase {
+ public:
+  TcEnableTcExec(ploc::SpTcParams params, uint16_t sequenceCount)
+      : TcBase(params, apid::TC_ENABLE_TC_EXECUTION, sequenceCount) {
+    spParams.setFullPayloadLen(CRC_SIZE);
+  }
+
+  ReturnValue_t setPayload(const uint8_t* cmdData, size_t cmdDataLen) {
+    if (cmdDataLen != 2) {
+      return HasActionsIF::INVALID_PARAMETERS;
+    }
+    std::memcpy(payloadStart, cmdData, 2);
+    spParams.setFullPayloadLen(2 + CRC_SIZE);
+    return returnvalue::OK;
+  }
+};
+
+class TcFlashMkfs : public TcBase {
+ public:
+  TcFlashMkfs(ploc::SpTcParams params, uint16_t sequenceCount, FlashId flashId)
+      : TcBase(params, apid::TC_FLASH_MKFS, sequenceCount) {
+    const char* flashIdStr = "0:\\";
+    if (flashId == FlashId::FLASH_1) {
+      flashIdStr = "1:\\";
+    }
+    std::memcpy(payloadStart, flashIdStr, 3);
+    // Null terminator
+    payloadStart[3] = 0;
+    spParams.setFullPayloadLen(4 + CRC_SIZE);
+  }
+};
+
 /**
  * @brief   Class to build flash write space packet.
  */
@@ -464,15 +583,6 @@ class TcFlashRead : public TcBase {
     if (result != returnvalue::OK) {
       return result;
     }
-    updateSpFields();
-    result = checkSizeAndSerializeHeader();
-    if (result != returnvalue::OK) {
-      return result;
-    }
-    result = calcAndSetCrc();
-    if (result != returnvalue::OK) {
-      return result;
-    }
     readSize = readLen;
     return result;
   }
@@ -490,20 +600,14 @@ class TcFlashDelete : public TcBase {
 
   ReturnValue_t setPayload(std::string filename) {
     size_t nameSize = filename.size();
-    spParams.setFullPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE);
+    spParams.setFullPayloadLen(FILENAME_FIELD_SIZE + CRC_SIZE);
     auto res = checkPayloadLen();
     if (res != returnvalue::OK) {
       return res;
     }
     std::memcpy(payloadStart, filename.c_str(), nameSize);
     *(payloadStart + nameSize) = NULL_TERMINATOR;
-
-    updateSpFields();
-    res = checkSizeAndSerializeHeader();
-    if (res != returnvalue::OK) {
-      return res;
-    }
-    return calcAndSetCrc();
+    return returnvalue::OK;
   }
 };
 
@@ -655,8 +759,9 @@ class TcGetDirContent : public TcBase {
     if (result != returnvalue::OK) {
       return result;
     }
+    std::memset(payloadStart, 0, 256);
     std::memcpy(payloadStart, commandData, commandDataLen);
-    payloadStart[255] = '\0';
+    payloadStart[255] = 0;
     return result;
   }
 };
@@ -697,7 +802,7 @@ class TcReplayWriteSeq : public TcBase {
   static const size_t USE_DECODING_LENGTH = 1;
 
   ReturnValue_t lengthCheck(size_t commandDataLen) {
-    if (commandDataLen > USE_DECODING_LENGTH + MAX_FILENAME_SIZE or
+    if (commandDataLen > USE_DECODING_LENGTH + FILENAME_FIELD_SIZE or
         checkPayloadLen() != returnvalue::OK) {
       sif::warning << "TcReplayWriteSeq: Command has invalid length " << commandDataLen
                    << std::endl;
@@ -710,24 +815,24 @@ class TcReplayWriteSeq : public TcBase {
 /**
  * @brief   Helps to extract the fields of the flash write command from the PUS packet.
  */
-class FlashBasePusCmd : public MPSoCReturnValuesIF {
+class FlashBasePusCmd {
  public:
   FlashBasePusCmd() = default;
   virtual ~FlashBasePusCmd() = default;
 
   virtual ReturnValue_t extractFields(const uint8_t* commandData, size_t commandDataLen) {
-    if (commandDataLen > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE + MAX_FILENAME_SIZE)) {
+    if (commandDataLen > FILENAME_FIELD_SIZE) {
       return INVALID_LENGTH;
     }
     size_t fileLen = strnlen(reinterpret_cast<const char*>(commandData), commandDataLen);
-    if (fileLen > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE)) {
+    if (fileLen > MAX_FILENAME_SIZE) {
       return FILENAME_TOO_LONG;
     }
     obcFile = std::string(reinterpret_cast<const char*>(commandData), fileLen);
     fileLen =
         strnlen(reinterpret_cast<const char*>(commandData + obcFile.size() + SIZE_NULL_TERMINATOR),
                 commandDataLen - obcFile.size() - 1);
-    if (fileLen > MAX_FILENAME_SIZE) {
+    if (fileLen > FILENAME_FIELD_SIZE) {
       return MPSOC_FILENAME_TOO_LONG;
     }
     mpsocFile = std::string(
@@ -738,11 +843,11 @@ class FlashBasePusCmd : public MPSoCReturnValuesIF {
 
   const std::string& getObcFile() const { return obcFile; }
 
-  const std::string& getMPSoCFile() const { return mpsocFile; }
+  const std::string& getMpsocFile() const { return mpsocFile; }
 
  protected:
   size_t getParsedSize() const {
-    return getObcFile().size() + getMPSoCFile().size() + 2 * SIZE_NULL_TERMINATOR;
+    return getObcFile().size() + getMpsocFile().size() + 2 * SIZE_NULL_TERMINATOR;
   }
   static const size_t SIZE_NULL_TERMINATOR = 1;
 
@@ -809,49 +914,190 @@ class TcCamTakePic : public TcBase {
       : TcBase(params, apid::TC_CAM_TAKE_PIC, sequenceCount) {}
 
   ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
-    if (commandDataLen > MAX_DATA_LENGTH) {
+    const uint8_t** dataPtr = &commandData;
+    if (commandDataLen > FULL_PAYLOAD_SIZE) {
       return INVALID_LENGTH;
     }
-    std::string fileName(reinterpret_cast<const char*>(commandData));
-    if (fileName.size() + sizeof(NULL_TERMINATOR) > MAX_FILENAME_SIZE) {
+    size_t deserLen = commandDataLen;
+    size_t serLen = 0;
+    fileName = reinterpret_cast<const char*>(commandData);
+    if (fileName.size() > MAX_FILENAME_SIZE) {
       return FILENAME_TOO_LONG;
     }
-    if (commandDataLen - (fileName.size() + sizeof(NULL_TERMINATOR)) != PARAMETER_SIZE) {
-      return INVALID_LENGTH;
+    deserLen -= fileName.length() + 1;
+    *dataPtr += fileName.length() + 1;
+    uint8_t** payloadPtr = &payloadStart;
+    memcpy(payloadStart, fileName.data(), fileName.size());
+    *payloadPtr += FILENAME_FIELD_SIZE;
+    serLen += FILENAME_FIELD_SIZE;
+    ReturnValue_t result = SerializeAdapter::deSerialize(&encoderSettingY, dataPtr, &deserLen,
+                                                         SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
     }
-    spParams.setFullPayloadLen(commandDataLen + CRC_SIZE);
-    std::memcpy(payloadStart, commandData, commandDataLen);
+    result = SerializeAdapter::serialize(&encoderSettingY, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
+                                         SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+
+    result = SerializeAdapter::deSerialize(&quantizationY, dataPtr, &deserLen,
+                                           SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = SerializeAdapter::serialize(&quantizationY, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
+                                         SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+
+    result = SerializeAdapter::deSerialize(&encoderSettingsCb, dataPtr, &deserLen,
+                                           SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = SerializeAdapter::serialize(&encoderSettingsCb, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
+                                         SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+
+    result = SerializeAdapter::deSerialize(&quantizationCb, dataPtr, &deserLen,
+                                           SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = SerializeAdapter::serialize(&quantizationCb, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
+                                         SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+
+    result = SerializeAdapter::deSerialize(&encoderSettingsCr, dataPtr, &deserLen,
+                                           SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = SerializeAdapter::serialize(&encoderSettingsCr, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
+                                         SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+
+    result = SerializeAdapter::deSerialize(&quantizationCr, dataPtr, &deserLen,
+                                           SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = SerializeAdapter::serialize(&quantizationCr, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
+                                         SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+
+    result = SerializeAdapter::deSerialize(&bypassCompressor, dataPtr, &deserLen,
+                                           SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = SerializeAdapter::serialize(&bypassCompressor, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
+                                         SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+
+    spParams.setFullPayloadLen(FULL_PAYLOAD_SIZE + CRC_SIZE);
     return returnvalue::OK;
   }
 
+  std::string fileName;
+  uint8_t encoderSettingY = 7;
+  uint64_t quantizationY = 0;
+  uint8_t encoderSettingsCb = 7;
+  uint64_t quantizationCb = 0;
+  uint8_t encoderSettingsCr = 7;
+  uint64_t quantizationCr = 0;
+  uint8_t bypassCompressor = 0;
+
  private:
-  static const size_t MAX_DATA_LENGTH = 286;
   static const size_t PARAMETER_SIZE = 28;
+  static constexpr size_t FULL_PAYLOAD_SIZE = FILENAME_FIELD_SIZE + PARAMETER_SIZE;
 };
 
 /**
  * @brief   Class to build simplex send file command
  */
-class TcSimplexSendFile : public TcBase {
+class TcSimplexStreamFile : public TcBase {
  public:
-  TcSimplexSendFile(ploc::SpTcParams params, uint16_t sequenceCount)
+  TcSimplexStreamFile(ploc::SpTcParams params, uint16_t sequenceCount)
       : TcBase(params, apid::TC_SIMPLEX_SEND_FILE, sequenceCount) {}
 
   ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
-    if (commandDataLen > MAX_DATA_LENGTH) {
+    if (commandDataLen > MAX_FILENAME_SIZE) {
       return INVALID_LENGTH;
     }
     std::string fileName(reinterpret_cast<const char*>(commandData));
-    if (fileName.size() + sizeof(NULL_TERMINATOR) > MAX_FILENAME_SIZE) {
+    if (fileName.size() > MAX_FILENAME_SIZE) {
       return FILENAME_TOO_LONG;
     }
-    spParams.setFullPayloadLen(commandDataLen + CRC_SIZE);
-    std::memcpy(payloadStart, commandData, commandDataLen);
+
+    std::memset(payloadStart, 0, FILENAME_FIELD_SIZE);
+    std::memcpy(payloadStart, fileName.data(), fileName.length());
+    payloadStart[fileName.length()] = 0;
+    spParams.setFullPayloadLen(FILENAME_FIELD_SIZE + CRC_SIZE);
+    ;
     return returnvalue::OK;
   }
 
  private:
-  static const size_t MAX_DATA_LENGTH = 256;
+};
+
+/**
+ * @brief   Class to build simplex send file command
+ */
+class TcSplitFile : public TcBase {
+ public:
+  TcSplitFile(ploc::SpTcParams params, uint16_t sequenceCount)
+      : TcBase(params, apid::TC_SIMPLEX_SEND_FILE, sequenceCount) {}
+
+  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
+    if (commandDataLen < MIN_DATA_LENGTH) {
+      return INVALID_LENGTH;
+    }
+    if (commandDataLen > MAX_DATA_LENGTH) {
+      return INVALID_LENGTH;
+    }
+    const uint8_t** dataPtr = &commandData;
+    ReturnValue_t result = SerializeAdapter::deSerialize(&chunkParameter, dataPtr, &commandDataLen,
+                                                         SerializeIF::Endianness::NETWORK);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    /// No chunks makes no sense, and DIV str can not be longer than whats representable with 3
+    /// decimal digits.
+    if (chunkParameter == 0 or chunkParameter > 999) {
+      return INVALID_PARAMETER;
+    }
+    std::string fileName(reinterpret_cast<const char*>(*dataPtr));
+    if (fileName.size() > MAX_FILENAME_SIZE) {
+      return FILENAME_TOO_LONG;
+    }
+    char divStr[16]{};
+    sprintf(divStr, "DIV%03u", chunkParameter);
+    std::memcpy(payloadStart, divStr, DIV_STR_LEN);
+    payloadStart[DIV_STR_LEN] = 0;
+    std::memset(payloadStart + DIV_STR_LEN + 1, 0, FILENAME_FIELD_SIZE - DIV_STR_LEN - 1);
+    std::memcpy(payloadStart + DIV_STR_LEN + 1, fileName.data(), fileName.length());
+    spParams.setFullPayloadLen(FILENAME_FIELD_SIZE + CRC_SIZE);
+    return returnvalue::OK;
+  }
+
+ private:
+  uint32_t chunkParameter = 0;
+  static constexpr size_t MIN_DATA_LENGTH = 4;
+  static constexpr size_t DIV_STR_LEN = 6;
+  static constexpr size_t MAX_DATA_LENGTH = 4 + MAX_FILENAME_SIZE;
 };
 
 /**

linux/payload/plocSupvDefs.h

@@ -1805,7 +1805,7 @@ class LatchupStatusReport : public StaticLocalDataSet<LATCHUP_RPT_SET_ENTRIES> {
   lp_var_t<uint8_t> timeMon = lp_var_t<uint8_t>(sid.objectId, PoolIds::LATCHUP_RPT_TIME_MON, this);
   lp_var_t<uint8_t> timeYear =
       lp_var_t<uint8_t>(sid.objectId, PoolIds::LATCHUP_RPT_TIME_YEAR, this);
-  lp_var_t<uint8_t> isSet = lp_var_t<uint8_t>(sid.objectId, PoolIds::LATCHUP_RPT_IS_SET, this);
+  lp_var_t<uint8_t> isSynced = lp_var_t<uint8_t>(sid.objectId, PoolIds::LATCHUP_RPT_IS_SET, this);
 
   static const uint8_t IS_SET_BIT_POS = 15;
 };

mission/acs/str/ArcsecDatalinkLayer.cpp

@@ -32,7 +32,7 @@ ReturnValue_t ArcsecDatalinkLayer::checkRingBufForFrame(const uint8_t** decodedF
     size_t encodedDataSize = 0;
     slip_error_t slipError =
         slip_decode_frame(decodedRxFrame, &rxFrameSize, rxAnalysisBuffer + startIdx,
-                          idx - startIdx + 1, &encodedDataSize, ARC_DEF_SAGITTA_SLIP_ID);
+                          idx - startIdx + 1, &encodedDataSize, ARC_DEF_SAGITTA_SLIP_ID, 0);
     decodeRingBuf.deleteData(idx + 1);
     switch (slipError) {
       case (SLIP_OK): {
@@ -76,7 +76,7 @@ void ArcsecDatalinkLayer::reset() { decodeRingBuf.clear(); }
 
 void ArcsecDatalinkLayer::encodeFrame(const uint8_t* data, size_t length, const uint8_t** txFrame,
                                       size_t& size) {
-  slip_encode_frame(data, length, txEncoded, &size, ARC_DEF_SAGITTA_SLIP_ID);
+  slip_encode_frame(data, length, txEncoded, sizeof(txEncoded), &size, ARC_DEF_SAGITTA_SLIP_ID);
   if (txFrame != nullptr) {
     *txFrame = txEncoded;
   }

mission/acs/str/StarTrackerHandler.cpp

@@ -5,7 +5,12 @@
 #include <mission/acs/str/strHelpers.h>
 #include <mission/acs/str/strJsonCommands.h>
 
+#include <string>
+
+#include "fsfw/filesystem/HasFileSystemIF.h"
 #include "fsfw/ipc/MessageQueueIF.h"
+#include "fsfw/returnvalues/returnvalue.h"
+#include "mission/memory/SdCardMountedIF.h"
 
 extern "C" {
 #include <sagitta/client/actionreq.h>
@@ -16,7 +21,6 @@ extern "C" {
 }
 
 #include <atomic>
-#include <fstream>
 #include <thread>
 
 #include "OBSWConfig.h"
@@ -27,7 +31,8 @@ std::atomic_bool JCFG_DONE(false);
 
 StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
                                        StrComHandler* strHelper, power::Switch_t powerSwitch,
-                                       startracker::SdCardConfigPathGetter& cfgPathGetter)
+                                       startracker::SdCardConfigPathGetter& cfgPathGetter,
+                                       SdCardMountedIF& sdCardIF)
     : DeviceHandlerBase(objectId, comIF, comCookie),
       temperatureSet(this),
       versionSet(this),
@@ -58,8 +63,10 @@ StarTrackerHandler::StarTrackerHandler(object_id_t objectId, object_id_t comIF,
       centroidSet(this),
       centroidsSet(this),
       contrastSet(this),
+      blobStatsSet(this),
       strHelper(strHelper),
       powerSwitch(powerSwitch),
+      sdCardIF(sdCardIF),
       cfgPathGetter(cfgPathGetter) {
   if (comCookie == nullptr) {
     sif::error << "StarTrackerHandler: Invalid com cookie" << std::endl;
@@ -138,6 +145,9 @@ ReturnValue_t StarTrackerHandler::initialize() {
   // delay whole satellite boot process.
   reloadJsonCfgFile();
 
+  // Default firmware target is always initialized from persistent file.
+  loadTargetFirmwareFromPersistentCfg();
+
   EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
   if (manager == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -165,6 +175,19 @@ ReturnValue_t StarTrackerHandler::initialize() {
   return returnvalue::OK;
 }
 
+void StarTrackerHandler::loadTargetFirmwareFromPersistentCfg() {
+  const char* prefix = sdCardIF.getCurrentMountPrefix();
+  std::filesystem::path path = std::filesystem::path(prefix) / startracker::FW_TARGET_CFG_PATH;
+  std::ifstream ifile(path);
+  if (ifile.is_open() and !ifile.bad()) {
+    std::string targetStr;
+    std::getline(ifile, targetStr);
+    if (targetStr == "backup") {
+      firmwareTargetRaw = static_cast<uint8_t>(startracker::FirmwareTarget::BACKUP);
+    }
+  }
+}
+
 bool StarTrackerHandler::reloadJsonCfgFile() {
   jcfgCountdown.resetTimer();
   auto strCfgPath = cfgPathGetter.getCfgPath();
@@ -307,21 +330,11 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
       strHelper->setFlashReadFilename(std::string(reinterpret_cast<const char*>(data), size));
       return EXECUTION_FINISHED;
     }
-    case (startracker::FIRMWARE_UPDATE): {
-      result = DeviceHandlerBase::acceptExternalDeviceCommands();
-      if (result != returnvalue::OK) {
-        return result;
+    case (startracker::FIRMWARE_UPDATE_MAIN): {
+      return handleFirmwareUpdateCommand(data, size, startracker::FirmwareTarget::MAIN);
     }
-      if (size > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
-        return FILE_PATH_TOO_LONG;
-      }
-      result =
-          strHelper->startFirmwareUpdate(std::string(reinterpret_cast<const char*>(data), size));
-      if (result != returnvalue::OK) {
-        return result;
-      }
-      strHelperHandlingSpecialRequest = true;
-      return EXECUTION_FINISHED;
+    case (startracker::FIRMWARE_UPDATE_BACKUP): {
+      return handleFirmwareUpdateCommand(data, size, startracker::FirmwareTarget::BACKUP);
     }
     default:
       break;
@@ -330,6 +343,23 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
   reinitNextSetParam = true;
   return DeviceHandlerBase::executeAction(actionId, commandedBy, data, size);
 }
+ReturnValue_t StarTrackerHandler::handleFirmwareUpdateCommand(const uint8_t* data, size_t size,
+                                                              startracker::FirmwareTarget target) {
+  ReturnValue_t result = DeviceHandlerBase::acceptExternalDeviceCommands();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  if (size > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
+    return FILE_PATH_TOO_LONG;
+  }
+  result = strHelper->startFirmwareUpdate(std::string(reinterpret_cast<const char*>(data), size),
+                                          target);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  strHelperHandlingSpecialRequest = true;
+  return EXECUTION_FINISHED;
+}
 
 void StarTrackerHandler::performOperationHook() {
   EventMessage event;
@@ -543,7 +573,7 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
       Clock::getClock(&tv);
       setTimeRequest.unixTime =
           (static_cast<uint64_t>(tv.tv_sec) * 1000 * 1000) + (static_cast<uint64_t>(tv.tv_usec));
-      arc_pack_settime_action_req(&setTimeRequest, commandBuffer, &rawPacketLen);
+      prv_arc_pack_settime_action_req(&setTimeRequest, commandBuffer, &rawPacketLen);
       size_t serLen = 0;
       // Time in milliseconds. Manual serialization because arcsec API ignores endianness.
       SerializeAdapter::serialize(&setTimeRequest.unixTime, commandBuffer + 2, &serLen,
@@ -568,8 +598,12 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
       prepareRequestContrastTm();
       return returnvalue::OK;
     }
+    case (startracker::REQ_BLOB_STATS): {
+      prepareRequestBlobStatsTm();
+      return returnvalue::OK;
+    }
     case (startracker::BOOT): {
-      prepareBootCommand();
+      prepareBootCommand(static_cast<startracker::FirmwareTarget>(firmwareTargetRaw));
       return returnvalue::OK;
     }
     case (startracker::REQ_VERSION): {
@@ -856,6 +890,8 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
   this->insertInCommandAndReplyMap(startracker::REQ_CONTRAST, 3, &contrastSet,
                                    startracker::MAX_FRAME_SIZE * 2 + 2);
+  this->insertInCommandAndReplyMap(startracker::REQ_BLOB_STATS, 3, &blobStatsSet,
+                                   startracker::MAX_FRAME_SIZE * 2 + 2);
 }
 
 ReturnValue_t StarTrackerHandler::isModeCombinationValid(Mode_t mode, Submode_t submode) {
@@ -1053,6 +1089,12 @@ void StarTrackerHandler::resetSecondaryTmSet() {
       histogramSet.setValidity(false, true);
     }
   }
+  {
+    PoolReadGuard pg(&blobStatsSet);
+    if (pg.getReadResult() == returnvalue::OK) {
+      histogramSet.setValidity(false, true);
+    }
+  }
 }
 
 void StarTrackerHandler::bootBootloader() {
@@ -1201,6 +1243,10 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
       result = handleTm(packet, histogramSet, "REQ_HISTO");
       break;
     }
+    case (startracker::REQ_BLOB_STATS): {
+      result = handleTm(packet, blobStatsSet, "REQ_BLOB_STATS");
+      break;
+    }
     case (startracker::SUBSCRIPTION):
     case (startracker::LOGLEVEL):
     case (startracker::LOGSUBSCRIPTION):
@@ -1602,6 +1648,13 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
   localDataPoolMap.emplace(startracker::PoolIds::CONTRAST_C, new PoolEntry<uint32_t>(9));
   localDataPoolMap.emplace(startracker::PoolIds::CONTRAST_D, new PoolEntry<uint32_t>(9));
 
+  localDataPoolMap.emplace(startracker::TICKS_BLOB_STATS, new PoolEntry<uint32_t>());
+  localDataPoolMap.emplace(startracker::TIME_BLOB_STATS, new PoolEntry<uint64_t>());
+  localDataPoolMap.emplace(startracker::PoolIds::BLOB_STATS_NOISE, new PoolEntry<uint8_t>(16));
+  localDataPoolMap.emplace(startracker::PoolIds::BLOB_STATS_THOLD, new PoolEntry<uint8_t>(16));
+  localDataPoolMap.emplace(startracker::PoolIds::BLOB_STATS_LVALID, new PoolEntry<uint8_t>(16));
+  localDataPoolMap.emplace(startracker::PoolIds::BLOB_STATS_OFLOW, new PoolEntry<uint8_t>(16));
+
   poolManager.subscribeForDiagPeriodicPacket(
       subdp::DiagnosticsHkPeriodicParams(temperatureSet.getSid(), false, 10.0));
   poolManager.subscribeForRegularPeriodicPacket(
@@ -1630,6 +1683,8 @@ ReturnValue_t StarTrackerHandler::initializeLocalDataPool(localpool::DataPool& l
       subdp::RegularHkPeriodicParams(centroidsSet.getSid(), false, 10.0));
   poolManager.subscribeForRegularPeriodicPacket(
       subdp::RegularHkPeriodicParams(contrastSet.getSid(), false, 10.0));
+  poolManager.subscribeForRegularPeriodicPacket(
+      subdp::RegularHkPeriodicParams(blobStatsSet.getSid(), false, 10.0));
   return returnvalue::OK;
 }
 
@@ -1659,7 +1714,8 @@ ReturnValue_t StarTrackerHandler::checkMode(ActionId_t actionId) {
     case startracker::UPLOAD_IMAGE:
     case startracker::DOWNLOAD_IMAGE:
     case startracker::FLASH_READ:
-    case startracker::FIRMWARE_UPDATE: {
+    case startracker::FIRMWARE_UPDATE_BACKUP:
+    case startracker::FIRMWARE_UPDATE_MAIN: {
       return DeviceHandlerBase::acceptExternalDeviceCommands();
       default:
         break;
@@ -1875,6 +1931,10 @@ ReturnValue_t StarTrackerHandler::scanForTmReply(uint8_t replyId, DeviceCommandI
       *foundId = startracker::REQ_BLOB;
       break;
     }
+    case (startracker::ID::BLOB_STATS): {
+      *foundId = startracker::REQ_BLOB_STATS;
+      break;
+    }
     case (startracker::ID::BLOBS): {
       *foundId = startracker::REQ_BLOBS;
       break;
@@ -1956,10 +2016,10 @@ ReturnValue_t StarTrackerHandler::executeFlashReadCommand(const uint8_t* command
   return result;
 }
 
-void StarTrackerHandler::prepareBootCommand() {
+void StarTrackerHandler::prepareBootCommand(startracker::FirmwareTarget target) {
   uint32_t length = 0;
-  struct BootActionRequest bootRequest = {BOOT_REGION_ID};
-  arc_pack_boot_action_req(&bootRequest, commandBuffer, &length);
+  struct BootActionRequest bootRequest = {static_cast<uint8_t>(target)};
+  prv_arc_pack_boot_action_req(&bootRequest, commandBuffer, &length);
   rawPacket = commandBuffer;
   rawPacketLen = length;
 }
@@ -1992,7 +2052,7 @@ ReturnValue_t StarTrackerHandler::prepareChecksumCommand(const uint8_t* commandD
     return result;
   }
   uint32_t rawCmdLength = 0;
-  arc_pack_checksum_action_req(&req, commandBuffer, &rawCmdLength);
+  prv_arc_pack_checksum_action_req(&req, commandBuffer, &rawCmdLength);
   rawPacket = commandBuffer;
   rawPacketLen = rawCmdLength;
   checksumCmd.rememberRegion = req.region;
@@ -2011,7 +2071,7 @@ void StarTrackerHandler::prepareTimeRequest() {
 void StarTrackerHandler::preparePingRequest() {
   uint32_t length = 0;
   struct PingActionRequest pingRequest = {PING_ID};
-  arc_pack_ping_action_req(&pingRequest, commandBuffer, &length);
+  prv_arc_pack_ping_action_req(&pingRequest, commandBuffer, &length);
   rawPacket = commandBuffer;
   rawPacketLen = length;
 }
@@ -2040,7 +2100,7 @@ void StarTrackerHandler::preparePowerRequest() {
 void StarTrackerHandler::prepareSwitchToBootloaderCmd() {
   uint32_t length = 0;
   struct RebootActionRequest rebootReq {};
-  arc_pack_reboot_action_req(&rebootReq, commandBuffer, &length);
+  prv_arc_pack_reboot_action_req(&rebootReq, commandBuffer, &length);
   rawPacket = commandBuffer;
   rawPacketLen = length;
 }
@@ -2049,7 +2109,7 @@ void StarTrackerHandler::prepareTakeImageCommand(const uint8_t* commandData) {
   uint32_t length = 0;
   struct CameraActionRequest camReq;
   camReq.actionid = *commandData;
-  arc_pack_camera_action_req(&camReq, commandBuffer, &length);
+  prv_arc_pack_camera_action_req(&camReq, commandBuffer, &length);
   rawPacket = commandBuffer;
   rawPacketLen = length;
 }
@@ -2115,6 +2175,14 @@ ReturnValue_t StarTrackerHandler::prepareRequestCentroidTm() {
   return returnvalue::OK;
 }
 
+ReturnValue_t StarTrackerHandler::prepareRequestBlobStatsTm() {
+  uint32_t length = 0;
+  arc_tm_pack_blobstats_req(commandBuffer, &length);
+  rawPacket = commandBuffer;
+  rawPacketLen = length;
+  return returnvalue::OK;
+}
+
 ReturnValue_t StarTrackerHandler::prepareRequestCentroidsTm() {
   uint32_t length = 0;
   arc_tm_pack_centroids_req(commandBuffer, &length);
@@ -2389,7 +2457,8 @@ ReturnValue_t StarTrackerHandler::checkProgram() {
         internalState = InternalState::DONE;
       }
       break;
-    case startracker::Program::FIRMWARE:
+    case startracker::Program::FIRMWARE_BACKUP:
+    case startracker::Program::FIRMWARE_MAIN: {
       if (startupState == StartupState::WAIT_CHECK_PROGRAM) {
         startupState = StartupState::BOOT_BOOTLOADER;
       }
@@ -2400,9 +2469,10 @@ ReturnValue_t StarTrackerHandler::checkProgram() {
         internalState = InternalState::FAILED_BOOTLOADER_BOOT;
       }
       break;
+    }
     default:
-      sif::warning << "StarTrackerHandler::checkProgram: Version set has invalid program ID"
-                   << std::endl;
+      sif::warning << "StarTrackerHandler::checkProgram: Version set has invalid program ID "
+                   << static_cast<int>(versionSet.program.value) << std::endl;
       return INVALID_PROGRAM;
   }
   return returnvalue::OK;
@@ -2862,17 +2932,19 @@ ReturnValue_t StarTrackerHandler::checkCommand(ActionId_t actionId) {
     case startracker::REQ_MATCHED_CENTROIDS:
     case startracker::REQ_BLOB:
     case startracker::REQ_BLOBS:
+    case startracker::REQ_BLOB_STATS:
     case startracker::REQ_CENTROID:
     case startracker::REQ_CENTROIDS:
     case startracker::REQ_CONTRAST: {
-      if (getMode() == MODE_ON and getSubmode() != startracker::Program::FIRMWARE) {
+      if (getMode() == MODE_ON and getSubmode() != startracker::SUBMODE_FIRMWARE) {
         return STARTRACKER_NOT_RUNNING_FIRMWARE;
       }
       break;
     }
-    case startracker::FIRMWARE_UPDATE:
+    case startracker::FIRMWARE_UPDATE_MAIN:
+    case startracker::FIRMWARE_UPDATE_BACKUP:
     case startracker::FLASH_READ:
-      if (getMode() != MODE_ON or getSubmode() != startracker::Program::BOOTLOADER) {
+      if (getMode() != MODE_ON or getSubmode() != startracker::SUBMODE_BOOTLOADER) {
         return STARTRACKER_NOT_RUNNING_BOOTLOADER;
       }
       break;
@@ -2883,3 +2955,42 @@ ReturnValue_t StarTrackerHandler::checkCommand(ActionId_t actionId) {
 }
 
 ReturnValue_t StarTrackerHandler::acceptExternalDeviceCommands() { return returnvalue::OK; }
+
+ReturnValue_t StarTrackerHandler::getParameter(uint8_t domainId, uint8_t uniqueId,
+                                               ParameterWrapper* parameterWrapper,
+                                               const ParameterWrapper* newValues,
+                                               uint16_t startAtIndex) {
+  auto firmwareTargetUpdate = [&](bool persistent) {
+    uint8_t value = 0;
+    newValues->getElement(&value);
+    if (value != static_cast<uint8_t>(startracker::FirmwareTarget::MAIN) &&
+        value != static_cast<uint8_t>(startracker::FirmwareTarget::BACKUP)) {
+      return HasParametersIF::INVALID_VALUE;
+    }
+    parameterWrapper->set(firmwareTargetRaw);
+    if (persistent) {
+      if (sdCardIF.isSdCardUsable(std::nullopt)) {
+        const char* prefix = sdCardIF.getCurrentMountPrefix();
+        std::filesystem::path path =
+            std::filesystem::path(prefix) / startracker::FW_TARGET_CFG_PATH;
+        std::ofstream of(path, std::ofstream::out | std::ofstream::trunc);
+        if (value == static_cast<uint8_t>(startracker::FirmwareTarget::MAIN)) {
+          of << "main\n";
+        } else {
+          of << "backup\n";
+        }
+      } else {
+        return HasFileSystemIF::FILESYSTEM_INACTIVE;
+      }
+    };
+    return returnvalue::OK;
+  };
+  if (uniqueId == startracker::ParamId::FIRMWARE_TARGET) {
+    return firmwareTargetUpdate(false);
+  }
+  if (uniqueId == startracker::ParamId::FIRMWARE_TARGET_PERSISTENT) {
+    return firmwareTargetUpdate(true);
+  }
+  return DeviceHandlerBase::getParameter(domainId, uniqueId, parameterWrapper, newValues,
+                                         startAtIndex);
+}

mission/acs/str/StarTrackerHandler.h

@@ -11,10 +11,7 @@
 #include <set>
 #include <thread>
 
-#include "OBSWConfig.h"
-#include "devices/powerSwitcherList.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
-#include "fsfw/src/fsfw/serialize/SerializeAdapter.h"
 #include "fsfw/timemanager/Countdown.h"
 
 extern "C" {
@@ -45,7 +42,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
    */
   StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
                      StrComHandler* strHelper, power::Switch_t powerSwitch,
-                     startracker::SdCardConfigPathGetter& cfgPathGetter);
+                     startracker::SdCardConfigPathGetter& cfgPathGetter, SdCardMountedIF& sdCardIF);
   virtual ~StarTrackerHandler();
 
   ReturnValue_t initialize() override;
@@ -61,6 +58,9 @@ class StarTrackerHandler : public DeviceHandlerBase {
 
   Submode_t getInitialSubmode() override;
 
+  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper* parameterWrapper,
+                             const ParameterWrapper* newValues, uint16_t startAtIndex) override;
+
  protected:
   void doStartUp() override;
   void doShutDown() override;
@@ -161,7 +161,8 @@ class StarTrackerHandler : public DeviceHandlerBase {
 
   // Ping request will reply ping with this ID (data field)
   static const uint32_t PING_ID = 0x55;
-  static const uint32_t BOOT_REGION_ID = 1;
+  uint8_t firmwareTargetRaw = static_cast<uint8_t>(startracker::FirmwareTarget::MAIN);
+
   static const MutexIF::TimeoutType TIMEOUT_TYPE = MutexIF::TimeoutType::WAITING;
   static const uint32_t MUTEX_TIMEOUT = 20;
   static const uint32_t BOOT_TIMEOUT = 1000;
@@ -215,6 +216,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
   startracker::CentroidSet centroidSet;
   startracker::CentroidsSet centroidsSet;
   startracker::ContrastSet contrastSet;
+  startracker::BlobStatsSet blobStatsSet;
 
   // Pointer to object responsible for uploading and downloading images to/from the star tracker
   StrComHandler* strHelper = nullptr;
@@ -314,12 +316,14 @@ class StarTrackerHandler : public DeviceHandlerBase {
   std::set<DeviceCommandId_t> additionalRequestedTm{};
   std::set<DeviceCommandId_t>::iterator currentSecondaryTmIter;
 
+  SdCardMountedIF& sdCardIF;
   startracker::SdCardConfigPathGetter& cfgPathGetter;
 
   /**
    * @brief   Handles internal state
    */
   void handleInternalState();
+  void loadTargetFirmwareFromPersistentCfg();
 
   /**
    * @brief   Checks mode for commands requiring MODE_ON of MODE_NORMAL for execution.
@@ -380,7 +384,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
    * @brief   Fills command buffer with data to boot image (works only when star tracker is
    *          in bootloader mode).
    */
-  void prepareBootCommand();
+  void prepareBootCommand(startracker::FirmwareTarget target);
 
   /**
    * @brief   Fills command buffer with command to get the checksum of a flash part
@@ -467,6 +471,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
   ReturnValue_t prepareRequestCentroidTm();
   ReturnValue_t prepareRequestCentroidsTm();
   ReturnValue_t prepareRequestContrastTm();
+  ReturnValue_t prepareRequestBlobStatsTm();
   ReturnValue_t prepareRequestTrackingParams();
   ReturnValue_t prepareRequestValidationParams();
   ReturnValue_t prepareRequestAlgoParams();
@@ -550,6 +555,9 @@ class StarTrackerHandler : public DeviceHandlerBase {
   void bootBootloader();
   bool reloadJsonCfgFile();
   ReturnValue_t acceptExternalDeviceCommands() override;
+
+  ReturnValue_t handleFirmwareUpdateCommand(const uint8_t* data, size_t size,
+                                            startracker::FirmwareTarget target);
 };
 
 #endif /* MISSION_DEVICES_STARTRACKERHANDLER_H_ */

mission/acs/str/strHelpers.h

@@ -14,6 +14,12 @@ namespace startracker {
 static const Submode_t SUBMODE_BOOTLOADER = 1;
 static const Submode_t SUBMODE_FIRMWARE = 2;
 
+enum class FirmwareTarget : uint8_t { MAIN = 1, BACKUP = 10 };
+
+static constexpr char FW_TARGET_CFG_PATH[] = "startracker/fw-target.txt";
+
+enum ParamId : uint32_t { FIRMWARE_TARGET = 1, FIRMWARE_TARGET_PERSISTENT = 2 };
+
 class SdCardConfigPathGetter {
  public:
   virtual ~SdCardConfigPathGetter() = default;
@@ -322,6 +328,13 @@ enum PoolIds : lp_id_t {
   CONTRAST_B,
   CONTRAST_C,
   CONTRAST_D,
+
+  TICKS_BLOB_STATS,
+  TIME_BLOB_STATS,
+  BLOB_STATS_NOISE,
+  BLOB_STATS_THOLD,
+  BLOB_STATS_LVALID,
+  BLOB_STATS_OFLOW,
 };
 
 static const DeviceCommandId_t PING_REQUEST = 0;
@@ -373,7 +386,7 @@ static const DeviceCommandId_t REQ_DEBUG_CAMERA = 80;
 static const DeviceCommandId_t LOGLEVEL = 81;
 static const DeviceCommandId_t LOGSUBSCRIPTION = 82;
 static const DeviceCommandId_t DEBUG_CAMERA = 83;
-static const DeviceCommandId_t FIRMWARE_UPDATE = 84;
+static const DeviceCommandId_t FIRMWARE_UPDATE_MAIN = 84;
 static const DeviceCommandId_t DISABLE_TIMESTAMP_GENERATION = 85;
 static const DeviceCommandId_t ENABLE_TIMESTAMP_GENERATION = 86;
 static constexpr DeviceCommandId_t SET_TIME_FROM_SYS_TIME = 87;
@@ -388,6 +401,9 @@ static constexpr DeviceCommandId_t ADD_SECONDARY_TM_TO_NORMAL_MODE = 95;
 static constexpr DeviceCommandId_t RESET_SECONDARY_TM_SET = 96;
 static constexpr DeviceCommandId_t READ_SECONDARY_TM_SET = 97;
 static constexpr DeviceCommandId_t RELOAD_JSON_CFG_FILE = 100;
+static constexpr DeviceCommandId_t FIRMWARE_UPDATE_BACKUP = 101;
+static constexpr DeviceCommandId_t REQ_BLOB_STATS = 102;
+
 static const DeviceCommandId_t NONE = 0xFFFFFFFF;
 
 static const uint32_t VERSION_SET_ID = REQ_VERSION;
@@ -419,6 +435,7 @@ static const uint32_t BLOBS_SET_ID = REQ_BLOBS;
 static const uint32_t CENTROID_SET_ID = REQ_CENTROID;
 static const uint32_t CENTROIDS_SET_ID = REQ_CENTROIDS;
 static const uint32_t CONTRAST_SET_ID = REQ_CONTRAST;
+static const uint32_t BLOB_STATS_SET_ID = REQ_BLOB_STATS;
 
 /** Max size of unencoded frame */
 static const size_t MAX_FRAME_SIZE = 1200;
@@ -485,11 +502,13 @@ static constexpr uint8_t CENTROID = 26;
 static constexpr uint8_t CENTROIDS = 37;
 static constexpr uint8_t AUTO_BLOB = 39;
 static constexpr uint8_t MATCHED_CENTROIDS = 40;
+static constexpr uint8_t BLOB_STATS = 49;
 }  // namespace ID
 
 namespace Program {
 static const uint8_t BOOTLOADER = 1;
-static const uint8_t FIRMWARE = 2;
+static const uint8_t FIRMWARE_MAIN = 2;
+static const uint8_t FIRMWARE_BACKUP = 3;
 }  // namespace Program
 
 namespace region_secrets {
@@ -509,7 +528,7 @@ static const uint32_t REGION_12_SECRET = 0x42fedef6;
 static const uint32_t REGION_13_SECRET = 0xe53cf10d;
 static const uint32_t REGION_14_SECRET = 0xe862b70b;
 static const uint32_t REGION_15_SECRET = 0x79b537ca;
-static const uint32_t secret[16]{
+static const uint32_t SECRETS[16]{
     REGION_0_SECRET,  REGION_1_SECRET,  REGION_2_SECRET,  REGION_3_SECRET,
     REGION_4_SECRET,  REGION_5_SECRET,  REGION_6_SECRET,  REGION_7_SECRET,
     REGION_8_SECRET,  REGION_9_SECRET,  REGION_10_SECRET, REGION_11_SECRET,
@@ -538,7 +557,12 @@ enum class FlashSections : uint8_t {
 };
 
 // Flash region IDs of firmware partition
-enum class FirmwareRegions : uint32_t { FIRST = 1, LAST = 8 };
+enum class FirmwareRegions : uint32_t {
+  FIRST_MAIN = 1,
+  LAST_MAIN = 8,
+  FIRST_BACKUP = 10,
+  LAST_BACKUP = 16
+};
 
 static const uint32_t FLASH_REGION_SIZE = 0x20000;
 
@@ -1545,6 +1569,23 @@ class CentroidsSet : public StaticLocalDataSet<10> {
       lp_vec_t<uint8_t, 16>(sid.objectId, PoolIds::CENTROIDS_MAGNITUDES, this);
 };
 
+class BlobStatsSet : public StaticLocalDataSet<6> {
+ public:
+  BlobStatsSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, BLOB_STATS_SET_ID) {}
+
+  // Data received from the Centroids Telemetry Set (ID 49)
+  lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_BLOB_STATS, this);
+  lp_var_t<uint64_t> time = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_BLOB_STATS, this);
+  lp_vec_t<uint8_t, 16> noise =
+      lp_vec_t<uint8_t, 16>(sid.objectId, PoolIds::BLOB_STATS_NOISE, this);
+  lp_vec_t<uint8_t, 16> thold =
+      lp_vec_t<uint8_t, 16>(sid.objectId, PoolIds::BLOB_STATS_THOLD, this);
+  lp_vec_t<uint8_t, 16> lvalid =
+      lp_vec_t<uint8_t, 16>(sid.objectId, PoolIds::BLOB_STATS_LVALID, this);
+  lp_vec_t<uint8_t, 16> oflow =
+      lp_vec_t<uint8_t, 16>(sid.objectId, PoolIds::BLOB_STATS_OFLOW, this);
+};
+
 class ContrastSet : public StaticLocalDataSet<8> {
  public:
   ContrastSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, CONTRAST_SET_ID) {}

mission/controller/AcsController.cpp

@@ -6,6 +6,7 @@ AcsController::AcsController(object_id_t objectId, bool enableHkSets, SdCardMoun
       sdcMan(sdcMan),
       attitudeEstimation(&acsParameters),
       fusedRotationEstimation(&acsParameters),
+      navigation(&acsParameters),
       guidance(&acsParameters),
       safeCtrl(&acsParameters),
       ptgCtrl(&acsParameters),
@@ -63,7 +64,7 @@ ReturnValue_t AcsController::executeAction(ActionId_t actionId, MessageQueueId_t
     }
     case UPDATE_TLE: {
       if (size != 69 * 2) {
-        return INVALID_PARAMETERS;
+        return HasActionsIF::INVALID_PARAMETERS;
       }
       ReturnValue_t result = updateTle(data, data + 69, false);
       if (result != returnvalue::OK) {
@@ -84,8 +85,11 @@ ReturnValue_t AcsController::executeAction(ActionId_t actionId, MessageQueueId_t
       }
       std::memcpy(tle + 69, line2, 69);
       actionHelper.reportData(commandedBy, actionId, tle, 69 * 2);
-      return EXECUTION_FINISHED;
+      return HasActionsIF::EXECUTION_FINISHED;
     }
+    case (UPDATE_MEKF_STANDARD_DEVIATIONS):
+      navigation.updateMekfStandardDeviations(&acsParameters);
+      return HasActionsIF::EXECUTION_FINISHED;
     default: {
       return HasActionsIF::INVALID_ACTION_ID;
     }
@@ -173,10 +177,11 @@ void AcsController::performAttitudeControl() {
                            &susDataProcessed, &gyrDataProcessed, &gpsDataProcessed, &acsParameters);
   attitudeEstimation.quest(&susDataProcessed, &mgmDataProcessed, &attitudeEstimationData);
   fusedRotationEstimation.estimateFusedRotationRate(
-      &susDataProcessed, &mgmDataProcessed, &gyrDataProcessed, &sensorValues,
+      mode, &susDataProcessed, &mgmDataProcessed, &gyrDataProcessed, &sensorValues,
       &attitudeEstimationData, timeDelta, &fusedRotRateSourcesData, &fusedRotRateData);
   result = navigation.useMekf(&sensorValues, &gyrDataProcessed, &mgmDataProcessed,
-                              &susDataProcessed, &attitudeEstimationData, &acsParameters);
+                              &susDataProcessed, timeDelta, &attitudeEstimationData,
+                              acsParameters.kalmanFilterParameters.allowStr);
 
   if (result != MultiplicativeKalmanFilter::MEKF_RUNNING and
       result != MultiplicativeKalmanFilter::MEKF_INITIALIZED) {
@@ -396,7 +401,7 @@ void AcsController::performPointingCtrl() {
 
   bool allRwAvailable = true;
   double rwPseudoInv[4][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  ReturnValue_t result = guidance.getDistributionMatrixRw(&sensorValues, *rwPseudoInv);
+  ReturnValue_t result = guidance.getDistributionMatrixRw(&sensorValues, *rwPseudoInv, &rwAvail);
   if (result == acsctrl::MULTIPLE_RW_UNAVAILABLE) {
     if (multipleRwUnavailableCounter >=
         acsParameters.rwHandlingParameters.multipleRwInvalidTimeout) {
@@ -433,10 +438,10 @@ void AcsController::performPointingCtrl() {
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, acsParameters.rwHandlingParameters.maxTrq);
       ptgCtrl.ptgDesaturation(
-          &acsParameters.idleModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
-          mgmDataProcessed.mgmVecTot.isValid(), rotRateB, sensorValues.rw1Set.currSpeed.value,
-          sensorValues.rw2Set.currSpeed.value, sensorValues.rw3Set.currSpeed.value,
-          sensorValues.rw4Set.currSpeed.value, mgtDpDes);
+          allRwAvailable, &rwAvail, &acsParameters.idleModeControllerParameters,
+          mgmDataProcessed.mgmVecTot.value, mgmDataProcessed.mgmVecTot.isValid(),
+          sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+          sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value, mgtDpDes);
       break;
 
     case acs::PTG_TARGET:
@@ -456,10 +461,10 @@ void AcsController::performPointingCtrl() {
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, acsParameters.rwHandlingParameters.maxTrq);
       ptgCtrl.ptgDesaturation(
-          &acsParameters.targetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
-          mgmDataProcessed.mgmVecTot.isValid(), rotRateB, sensorValues.rw1Set.currSpeed.value,
-          sensorValues.rw2Set.currSpeed.value, sensorValues.rw3Set.currSpeed.value,
-          sensorValues.rw4Set.currSpeed.value, mgtDpDes);
+          allRwAvailable, &rwAvail, &acsParameters.targetModeControllerParameters,
+          mgmDataProcessed.mgmVecTot.value, mgmDataProcessed.mgmVecTot.isValid(),
+          sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+          sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value, mgtDpDes);
       break;
 
     case acs::PTG_TARGET_GS:
@@ -476,10 +481,10 @@ void AcsController::performPointingCtrl() {
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, acsParameters.rwHandlingParameters.maxTrq);
       ptgCtrl.ptgDesaturation(
-          &acsParameters.gsTargetModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
-          mgmDataProcessed.mgmVecTot.isValid(), rotRateB, sensorValues.rw1Set.currSpeed.value,
-          sensorValues.rw2Set.currSpeed.value, sensorValues.rw3Set.currSpeed.value,
-          sensorValues.rw4Set.currSpeed.value, mgtDpDes);
+          allRwAvailable, &rwAvail, &acsParameters.gsTargetModeControllerParameters,
+          mgmDataProcessed.mgmVecTot.value, mgmDataProcessed.mgmVecTot.isValid(),
+          sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+          sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value, mgtDpDes);
       break;
 
     case acs::PTG_NADIR:
@@ -498,10 +503,10 @@ void AcsController::performPointingCtrl() {
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, acsParameters.rwHandlingParameters.maxTrq);
       ptgCtrl.ptgDesaturation(
-          &acsParameters.nadirModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
-          mgmDataProcessed.mgmVecTot.isValid(), rotRateB, sensorValues.rw1Set.currSpeed.value,
-          sensorValues.rw2Set.currSpeed.value, sensorValues.rw3Set.currSpeed.value,
-          sensorValues.rw4Set.currSpeed.value, mgtDpDes);
+          allRwAvailable, &rwAvail, &acsParameters.nadirModeControllerParameters,
+          mgmDataProcessed.mgmVecTot.value, mgmDataProcessed.mgmVecTot.isValid(),
+          sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+          sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value, mgtDpDes);
       break;
 
     case acs::PTG_INERTIAL:
@@ -520,10 +525,10 @@ void AcsController::performPointingCtrl() {
       VectorOperations<double>::add(torquePtgRws, rwTrqNs, torqueRws, 4);
       actuatorCmd.scalingTorqueRws(torqueRws, acsParameters.rwHandlingParameters.maxTrq);
       ptgCtrl.ptgDesaturation(
-          &acsParameters.inertialModeControllerParameters, mgmDataProcessed.mgmVecTot.value,
-          mgmDataProcessed.mgmVecTot.isValid(), rotRateB, sensorValues.rw1Set.currSpeed.value,
-          sensorValues.rw2Set.currSpeed.value, sensorValues.rw3Set.currSpeed.value,
-          sensorValues.rw4Set.currSpeed.value, mgtDpDes);
+          allRwAvailable, &rwAvail, &acsParameters.inertialModeControllerParameters,
+          mgmDataProcessed.mgmVecTot.value, mgmDataProcessed.mgmVecTot.isValid(),
+          sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+          sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value, mgtDpDes);
       break;
     default:
       sif::error << "AcsController: Invalid mode for performPointingCtrl" << std::endl;

mission/controller/AcsController.h

@@ -89,6 +89,8 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
   int32_t cmdSpeedRws[4] = {0, 0, 0, 0};
   int16_t cmdDipoleMtqs[3] = {0, 0, 0};
 
+  acsctrl::RwAvail rwAvail;
+
 #if OBSW_THREAD_TRACING == 1
   uint32_t opCounter = 0;
 #endif
@@ -111,6 +113,7 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
   static const DeviceCommandId_t RESTORE_MEKF_NONFINITE_RECOVERY = 0x2;
   static const DeviceCommandId_t UPDATE_TLE = 0x3;
   static const DeviceCommandId_t READ_TLE = 0x4;
+  static const DeviceCommandId_t UPDATE_MEKF_STANDARD_DEVIATIONS = 0x5;
 
   ReturnValue_t initialize() override;
   ReturnValue_t handleCommandMessage(CommandMessage* message) override;

mission/controller/PowerController.cpp

@@ -182,7 +182,7 @@ void PowerController::calculateStateOfCharge() {
   }
 
   // calculate total battery current
-  iBat = p60CoreHk.batteryCurrent.value + bpxBatteryHk.dischargeCurrent.value;
+  iBat = p60CoreHk.batteryCurrent.value - bpxBatteryHk.dischargeCurrent.value;
 
   result = calculateOpenCircuitVoltageCharge();
   if (result != returnvalue::OK) {

mission/controller/PowerController.h

@@ -57,9 +57,9 @@ class PowerController : public ExtendedControllerBase, public ReceivesParameterM
   float batteryMaximumCapacity = 2.6 * 2;            // [Ah]
   float coulombCounterVoltageUpperThreshold = 16.2;  // [V]
   double maxAllowedTimeDiff = 1.5;                   // [s]
-  float payloadOpLimitOn = 0.90;                     // [%]
-  float payloadOpLimitLow = 0.75;                    // [%]
-  float higherModesLimit = 0.6;                      // [%]
+  float payloadOpLimitOn = 0.80;                     // [%]
+  float payloadOpLimitLow = 0.65;                    // [%]
+  float higherModesLimit = 0.60;                     // [%]
 
   // OCV Look-up-Table {[Ah],[V]}
   static constexpr uint8_t LOOK_UP_TABLE_MAX_IDX = 99;

mission/controller/ThermalController.cpp

@@ -1641,7 +1641,11 @@ bool ThermalController::chooseHeater(heater::Switch& switchNr, heater::Switch re
   bool heaterAvailable = true;
 
   HasHealthIF::HealthState mainHealth = heaterHandler.getHealth(switchNr);
+  heater::SwitchState mainState = heaterHandler.getSwitchState(switchNr);
   HasHealthIF::HealthState redHealth = heaterHandler.getHealth(redSwitchNr);
+  if (mainHealth == HasHealthIF::EXTERNAL_CONTROL and mainState == heater::SwitchState::ON) {
+    return false;
+  }
   if (mainHealth != HasHealthIF::HEALTHY) {
     if (redHealth == HasHealthIF::HEALTHY) {
       switchNr = redSwitchNr;
@@ -1656,6 +1660,7 @@ bool ThermalController::chooseHeater(heater::Switch& switchNr, heater::Switch re
   } else {
     ctrlCtx.redSwitchNrInUse = false;
   }
+
   return heaterAvailable;
 }
 
@@ -1792,7 +1797,8 @@ void ThermalController::heaterMaxDurationControl(
   for (unsigned i = 0; i < heater::Switch::NUMBER_OF_SWITCHES; i++) {
     // Right now, we only track the maximum duration for heater which were commanded by the TCS
     // controller.
-    if (currentHeaterStates[i] == heater::SwitchState::ON and
+    if (heaterHandler.getHealth(static_cast<heater::Switch>(i)) != HasHealthIF::EXTERNAL_CONTROL and
+        currentHeaterStates[i] == heater::SwitchState::ON and
         heaterStates[i].trackHeaterMaxBurnTime and
         heaterStates[i].heaterOnMaxBurnTime.hasTimedOut()) {
       heaterStates[i].switchTransition = false;

mission/controller/acs/AcsParameters.cpp

@@ -554,6 +554,9 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
         case 0xE:
           parameterWrapper->set(gsTargetModeControllerParameters.altitudeTgt);
           break;
+        case 0xF:
+          parameterWrapper->set(gsTargetModeControllerParameters.rotRateLimit);
+          break;
         default:
           return INVALID_IDENTIFIER_ID;
       }
@@ -717,22 +720,25 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
     case (0x11):  // KalmanFilterParameters
       switch (parameterId) {
         case 0x0:
-          parameterWrapper->set(kalmanFilterParameters.sensorNoiseSTR);
+          parameterWrapper->set(kalmanFilterParameters.sensorNoiseStr);
           break;
         case 0x1:
-          parameterWrapper->set(kalmanFilterParameters.sensorNoiseSS);
+          parameterWrapper->set(kalmanFilterParameters.sensorNoiseSus);
           break;
         case 0x2:
-          parameterWrapper->set(kalmanFilterParameters.sensorNoiseMAG);
+          parameterWrapper->set(kalmanFilterParameters.sensorNoiseMgm);
           break;
         case 0x3:
-          parameterWrapper->set(kalmanFilterParameters.sensorNoiseGYR);
+          parameterWrapper->set(kalmanFilterParameters.sensorNoiseGyr);
           break;
         case 0x4:
-          parameterWrapper->set(kalmanFilterParameters.sensorNoiseArwGYR);
+          parameterWrapper->set(kalmanFilterParameters.sensorNoiseGyrArw);
           break;
         case 0x5:
-          parameterWrapper->set(kalmanFilterParameters.sensorNoiseBsGYR);
+          parameterWrapper->set(kalmanFilterParameters.sensorNoiseGyrBs);
+          break;
+        case 0x6:
+          parameterWrapper->set(kalmanFilterParameters.allowStr);
           break;
         default:
           return INVALID_IDENTIFIER_ID;

mission/controller/acs/AcsParameters.h

@@ -8,6 +8,9 @@
 typedef unsigned char uint8_t;
 
 class AcsParameters : public HasParametersIF {
+ private:
+  static constexpr double DEG2RAD = M_PI / 180.;
+
  public:
   AcsParameters();
   virtual ~AcsParameters();
@@ -20,9 +23,9 @@ class AcsParameters : public HasParametersIF {
     double sampleTime = 0.4;  // [s]
     uint16_t ptgCtrlLostTimer = 750;
     uint8_t fusedRateSafeDuringEclipse = true;
-    uint8_t fusedRateFromStr = false;
-    uint8_t fusedRateFromQuest = false;
-    double questFilterWeight = 0.0;
+    uint8_t fusedRateFromStr = true;
+    uint8_t fusedRateFromQuest = true;
+    double questFilterWeight = 0.9;
   } onBoardParams;
 
   struct InertiaEIVE {
@@ -773,7 +776,7 @@ class AcsParameters : public HasParametersIF {
          0.167666815691513, 0.163137400730063, -0.000609874123906977, -0.00205336098697513,
          -0.000889232196185857, -0.00168429567131815}};
     float susBrightnessThreshold = 0.7;
-    float susVectorFilterWeight = .85;
+    float susVectorFilterWeight = .95;
     float susRateFilterWeight = .99;
   } susHandlingParameters;
 
@@ -854,7 +857,7 @@ class AcsParameters : public HasParametersIF {
   struct PointingLawParameters {
     double zeta = 0.3;
     double om = 0.3;
-    double omMax = 1 * M_PI / 180;
+    double omMax = 1 * DEG2RAD;
     double qiMin = 0.1;
 
     double gainNullspace = 0.01;
@@ -863,7 +866,7 @@ class AcsParameters : public HasParametersIF {
     double desatMomentumRef[3] = {0, 0, 0};
     double deSatGainFactor = 1000;
     uint8_t desatOn = true;
-    uint8_t useMekf = false;
+    uint8_t useMekf = true;
   } pointingLawParameters;
 
   struct IdleModeControllerParameters : PointingLawParameters {
@@ -876,15 +879,15 @@ class AcsParameters : public HasParametersIF {
     uint8_t timeElapsedMax = 10;  // rot rate calculations
 
     // Default is Stuttgart GS
-    double latitudeTgt = 48.7495 * M_PI / 180.;   // [rad] Latitude
-    double longitudeTgt = 9.10384 * M_PI / 180.;  // [rad] Longitude
+    double latitudeTgt = 48.7495 * DEG2RAD;   // [rad] Latitude
+    double longitudeTgt = 9.10384 * DEG2RAD;  // [rad] Longitude
     double altitudeTgt = 500;                 // [m]
 
     // For one-axis control:
     uint8_t avoidBlindStr = true;
     double blindAvoidStart = 1.5;
     double blindAvoidStop = 2.5;
-    double blindRotRate = 1 * M_PI / 180;
+    double blindRotRate = 1. * DEG2RAD;
   } targetModeControllerParameters;
 
   struct GsTargetModeControllerParameters : PointingLawParameters {
@@ -892,9 +895,10 @@ class AcsParameters : public HasParametersIF {
     uint8_t timeElapsedMax = 10;          // rot rate calculations
 
     // Default is Stuttgart GS
-    double latitudeTgt = 48.7495 * M_PI / 180.;   // [rad] Latitude
-    double longitudeTgt = 9.10384 * M_PI / 180.;  // [rad] Longitude
+    double latitudeTgt = 48.7495 * DEG2RAD;   // [rad] Latitude
+    double longitudeTgt = 9.10384 * DEG2RAD;  // [rad] Longitude
     double altitudeTgt = 500;                 // [m]
+    double rotRateLimit = .75 * DEG2RAD;
   } gsTargetModeControllerParameters;
 
   struct NadirModeControllerParameters : PointingLawParameters {
@@ -911,8 +915,8 @@ class AcsParameters : public HasParametersIF {
   } inertialModeControllerParameters;
 
   struct StrParameters {
-    double exclusionAngle = 20 * M_PI / 180;
-    double boresightAxis[3] = {0.7593, 0.0000, -0.6508};  // geometry frame
+    double exclusionAngle = 20. * DEG2RAD;
+    double boresightAxis[3] = {0.7593, 0.0000, -0.6508};  // body rf
   } strParameters;
 
   struct GpsParameters {
@@ -925,25 +929,27 @@ class AcsParameters : public HasParametersIF {
 
   struct SunModelParameters {
     float domega = 36000.771;
-    float omega_0 = 280.46 * M_PI / 180.;  // RAAN plus argument of
+    float omega_0 = 280.46 * DEG2RAD;  // RAAN plus argument of
                                        // perigee
     float m_0 = 357.5277;              // coefficients for mean anomaly
     float dm = 35999.049;              // coefficients for mean anomaly
-    float e = 23.4392911 * M_PI / 180.;    // angle of earth's rotation axis
-    float e1 = 0.74508 * M_PI / 180.;
+    float e = 23.4392911 * DEG2RAD;    // angle of earth's rotation axis
+    float e1 = 0.74508 * DEG2RAD;
 
-    float p1 = 6892. / 3600. * M_PI / 180.;  // some parameter
-    float p2 = 72. / 3600. * M_PI / 180.;    // some parameter
+    float p1 = 6892. / 3600. * DEG2RAD;  // some parameter
+    float p2 = 72. / 3600. * DEG2RAD;    // some parameter
   } sunModelParameters;
 
   struct KalmanFilterParameters {
-    double sensorNoiseSTR = 0.1 * M_PI / 180;
-    double sensorNoiseSS = 8 * M_PI / 180;
-    double sensorNoiseMAG = 4 * M_PI / 180;
-    double sensorNoiseGYR = 0.1 * M_PI / 180;
+    double sensorNoiseStr = 0.1 * DEG2RAD;
+    double sensorNoiseSus = 8. * DEG2RAD;
+    double sensorNoiseMgm = 4. * DEG2RAD;
+    double sensorNoiseGyr = 0.1 * DEG2RAD;
 
-    double sensorNoiseArwGYR = 3 * 0.0043 * M_PI / sqrt(10) / 180;  // Angular Random Walk
-    double sensorNoiseBsGYR = 3 * M_PI / 180 / 3600;                // Bias Stability
+    double sensorNoiseGyrArw = 3. * 0.0043 / sqrt(10) * DEG2RAD;  // Angular Random Walk
+    double sensorNoiseGyrBs = 3. / 3600. * DEG2RAD;               // Bias Stability
+
+    uint8_t allowStr = false;
   } kalmanFilterParameters;
 
   struct MagnetorquerParameter {
@@ -959,8 +965,8 @@ class AcsParameters : public HasParametersIF {
 
   struct DetumbleParameter {
     uint8_t detumblecounter = 75;  // 30 s
-    double omegaDetumbleStart = 2 * M_PI / 180;
-    double omegaDetumbleEnd = 1 * M_PI / 180;
+    double omegaDetumbleStart = 2 * DEG2RAD;
+    double omegaDetumbleEnd = 1 * DEG2RAD;
     double gainBdot = pow(10.0, -3.3);
     double gainFull = pow(10.0, -2.3);
     uint8_t useFullDetumbleLaw = false;

mission/controller/acs/AttitudeEstimation.cpp

@@ -41,8 +41,8 @@ void AttitudeEstimation::quest(acsctrl::SusDataProcessed *susData,
 
   // Sensor Weights
   double kSus = 0, kMgm = 0;
-  kSus = std::pow(acsParameters->kalmanFilterParameters.sensorNoiseSS, -2);
-  kMgm = std::pow(acsParameters->kalmanFilterParameters.sensorNoiseMAG, -2);
+  kSus = std::pow(acsParameters->kalmanFilterParameters.sensorNoiseSus, -2);
+  kMgm = std::pow(acsParameters->kalmanFilterParameters.sensorNoiseMgm, -2);
 
   // Weighted Vectors
   double weightedSusB[3] = {0, 0, 0}, weightedMgmB[3] = {0, 0, 0}, kSusVec[3] = {0, 0, 0},

mission/controller/acs/FusedRotationEstimation.cpp

@@ -5,18 +5,18 @@ FusedRotationEstimation::FusedRotationEstimation(AcsParameters *acsParameters_)
 }
 
 void FusedRotationEstimation::estimateFusedRotationRate(
-    acsctrl::SusDataProcessed *susDataProcessed, acsctrl::MgmDataProcessed *mgmDataProcessed,
-    acsctrl::GyrDataProcessed *gyrDataProcessed, ACS::SensorValues *sensorValues,
-    acsctrl::AttitudeEstimationData *attitudeEstimationData, const double timeDelta,
-    acsctrl::FusedRotRateSourcesData *fusedRotRateSourcesData,
+    const Mode_t mode, acsctrl::SusDataProcessed *susDataProcessed,
+    acsctrl::MgmDataProcessed *mgmDataProcessed, acsctrl::GyrDataProcessed *gyrDataProcessed,
+    ACS::SensorValues *sensorValues, acsctrl::AttitudeEstimationData *attitudeEstimationData,
+    const double timeDelta, acsctrl::FusedRotRateSourcesData *fusedRotRateSourcesData,
     acsctrl::FusedRotRateData *fusedRotRateData) {
   estimateFusedRotationRateStr(sensorValues, timeDelta, fusedRotRateSourcesData);
   estimateFusedRotationRateQuest(attitudeEstimationData, timeDelta, fusedRotRateSourcesData);
   estimateFusedRotationRateSusMgm(susDataProcessed, mgmDataProcessed, gyrDataProcessed,
                                   fusedRotRateSourcesData);
 
-  if (fusedRotRateSourcesData->rotRateTotalStr.isValid() and
-      acsParameters->onBoardParams.fusedRateFromStr) {
+  if (not(mode == acs::AcsMode::SAFE) and (fusedRotRateSourcesData->rotRateTotalStr.isValid() and
+                                           acsParameters->onBoardParams.fusedRateFromStr)) {
     PoolReadGuard pg(fusedRotRateData);
     if (pg.getReadResult() == returnvalue::OK) {
       std::memcpy(fusedRotRateData->rotRateOrthogonal.value, ZERO_VEC3, 3 * sizeof(double));
@@ -29,8 +29,9 @@ void FusedRotationEstimation::estimateFusedRotationRate(
       fusedRotRateData->rotRateSource.value = acs::rotrate::Source::STR;
       fusedRotRateData->rotRateSource.setValid(true);
     }
-  } else if (fusedRotRateSourcesData->rotRateTotalQuest.isValid() and
-             acsParameters->onBoardParams.fusedRateFromQuest) {
+  } else if (not(mode == acs::AcsMode::SAFE) and
+             (fusedRotRateSourcesData->rotRateTotalQuest.isValid() and
+              acsParameters->onBoardParams.fusedRateFromQuest)) {
     PoolReadGuard pg(fusedRotRateData);
     if (pg.getReadResult() == returnvalue::OK) {
       std::memcpy(fusedRotRateData->rotRateOrthogonal.value, ZERO_VEC3, 3 * sizeof(double));

mission/controller/acs/FusedRotationEstimation.h

@@ -12,7 +12,7 @@ class FusedRotationEstimation {
  public:
   FusedRotationEstimation(AcsParameters *acsParameters_);
 
-  void estimateFusedRotationRate(acsctrl::SusDataProcessed *susDataProcessed,
+  void estimateFusedRotationRate(const Mode_t mode, acsctrl::SusDataProcessed *susDataProcessed,
                                  acsctrl::MgmDataProcessed *mgmDataProcessed,
                                  acsctrl::GyrDataProcessed *gyrDataProcessed,
                                  ACS::SensorValues *sensorValues,

mission/controller/acs/Guidance.cpp

@@ -8,8 +8,8 @@ void Guidance::targetQuatPtgIdle(timeval timeAbsolute, const double timeDelta,
                                  const double sunDirI[3], const double posSatF[4],
                                  double targetQuat[4], double targetSatRotRate[3]) {
   // positive z-Axis of EIVE in direction of sun
-  double zAxisXI[3] = {0, 0, 0};
-  VectorOperations<double>::normalize(sunDirI, zAxisXI, 3);
+  double zAxisIX[3] = {0, 0, 0};
+  VectorOperations<double>::normalize(sunDirI, zAxisIX, 3);
 
   // determine helper vector to point x-Axis and therefore the STR away from Earth
   double helperXI[3] = {0, 0, 0}, posSatI[3] = {0, 0, 0};
@@ -17,39 +17,37 @@ void Guidance::targetQuatPtgIdle(timeval timeAbsolute, const double timeDelta,
   VectorOperations<double>::normalize(posSatI, helperXI, 3);
 
   // construct y-axis from helper vector and z-axis
-  double yAxisXI[3] = {0, 0, 0};
-  VectorOperations<double>::cross(zAxisXI, helperXI, yAxisXI);
-  VectorOperations<double>::normalize(yAxisXI, yAxisXI, 3);
+  double yAxisIX[3] = {0, 0, 0};
+  VectorOperations<double>::cross(zAxisIX, helperXI, yAxisIX);
+  VectorOperations<double>::normalize(yAxisIX, yAxisIX, 3);
 
   // x-axis completes RHS
-  double xAxisXI[3] = {0, 0, 0};
-  VectorOperations<double>::cross(yAxisXI, zAxisXI, xAxisXI);
-  VectorOperations<double>::normalize(xAxisXI, xAxisXI, 3);
+  double xAxisIX[3] = {0, 0, 0};
+  VectorOperations<double>::cross(yAxisIX, zAxisIX, xAxisIX);
+  VectorOperations<double>::normalize(xAxisIX, xAxisIX, 3);
 
   // join transformation matrix
-  double dcmXI[3][3] = {{xAxisXI[0], yAxisXI[0], zAxisXI[0]},
-                        {xAxisXI[1], yAxisXI[1], zAxisXI[1]},
-                        {xAxisXI[2], yAxisXI[2], zAxisXI[2]}};
-  QuaternionOperations::fromDcm(dcmXI, targetQuat);
+  double dcmIX[3][3] = {{xAxisIX[0], yAxisIX[0], zAxisIX[0]},
+                        {xAxisIX[1], yAxisIX[1], zAxisIX[1]},
+                        {xAxisIX[2], yAxisIX[2], zAxisIX[2]}};
+  QuaternionOperations::fromDcm(dcmIX, targetQuat);
 
   // calculate of reference rotation rate
   targetRotationRate(timeDelta, targetQuat, targetSatRotRate);
 }
 
-void Guidance::targetQuatPtgTarget(timeval timeAbsolute, const double timeDelta, double posSatF[3],
-                                   double velSatF[3], double targetQuat[4],
-                                   double targetSatRotRate[3]) {
+void Guidance::targetQuatPtgTarget(timeval timeAbsolute, const double timeDelta,
+                                   const double posSatF[3], const double velSatF[3],
+                                   double targetQuat[4], double targetSatRotRate[3]) {
   //-------------------------------------------------------------------------------------
   //	Calculation of target quaternion for target pointing
   //-------------------------------------------------------------------------------------
   // transform longitude, latitude and altitude to cartesian coordiantes (ECEF)
   double targetF[3] = {0, 0, 0};
-  MathOperations<double>::cartesianFromLatLongAlt(
+  CoordinateTransformations::cartesianFromLatLongAlt(
       acsParameters->targetModeControllerParameters.latitudeTgt,
       acsParameters->targetModeControllerParameters.longitudeTgt,
       acsParameters->targetModeControllerParameters.altitudeTgt, targetF);
-  double targetDirF[3] = {0, 0, 0};
-  VectorOperations<double>::subtract(targetF, posSatF, targetDirF, 3);
 
   // target direction in the ECI frame
   double posSatI[3] = {0, 0, 0}, targetI[3] = {0, 0, 0}, targetDirI[3] = {0, 0, 0};
@@ -59,8 +57,9 @@ void Guidance::targetQuatPtgTarget(timeval timeAbsolute, const double timeDelta,
 
   // x-axis aligned with target direction
   // this aligns with the camera, E- and S-band antennas
-  double xAxisXI[3] = {0, 0, 0};
-  VectorOperations<double>::normalize(targetDirI, xAxisXI, 3);
+  double xAxisIX[3] = {0, 0, 0};
+  VectorOperations<double>::normalize(targetDirI, xAxisIX, 3);
+  VectorOperations<double>::mulScalar(xAxisIX, -1, xAxisIX, 3);
 
   // transform velocity into inertial frame
   double velSatI[3] = {0, 0, 0};
@@ -73,32 +72,32 @@ void Guidance::targetQuatPtgTarget(timeval timeAbsolute, const double timeDelta,
 
   // y-axis of satellite in orbit plane so that z-axis is parallel to long side of picture
   // resolution
-  double yAxisXI[3] = {0, 0, 0};
-  VectorOperations<double>::cross(orbitalNormalI, xAxisXI, yAxisXI);
-  VectorOperations<double>::normalize(yAxisXI, yAxisXI, 3);
+  double yAxisIX[3] = {0, 0, 0};
+  VectorOperations<double>::cross(orbitalNormalI, xAxisIX, yAxisIX);
+  VectorOperations<double>::normalize(yAxisIX, yAxisIX, 3);
 
   // z-axis completes RHS
-  double zAxisXI[3] = {0, 0, 0};
-  VectorOperations<double>::cross(xAxisXI, yAxisXI, zAxisXI);
+  double zAxisIX[3] = {0, 0, 0};
+  VectorOperations<double>::cross(xAxisIX, yAxisIX, zAxisIX);
 
   // join transformation matrix
-  double dcmIX[3][3] = {{xAxisXI[0], yAxisXI[0], zAxisXI[0]},
-                        {xAxisXI[1], yAxisXI[1], zAxisXI[1]},
-                        {xAxisXI[2], yAxisXI[2], zAxisXI[2]}};
+  double dcmIX[3][3] = {{xAxisIX[0], yAxisIX[0], zAxisIX[0]},
+                        {xAxisIX[1], yAxisIX[1], zAxisIX[1]},
+                        {xAxisIX[2], yAxisIX[2], zAxisIX[2]}};
   QuaternionOperations::fromDcm(dcmIX, targetQuat);
 
   targetRotationRate(timeDelta, targetQuat, targetSatRotRate);
 }
 
-void Guidance::targetQuatPtgGs(timeval timeAbsolute, const double timeDelta, double posSatF[3],
-                               double sunDirI[3], double targetQuat[4],
-                               double targetSatRotRate[3]) {
+void Guidance::targetQuatPtgGs(timeval timeAbsolute, const double timeDelta,
+                               const double posSatF[3], const double sunDirI[3],
+                               double targetQuat[4], double targetSatRotRate[3]) {
   //-------------------------------------------------------------------------------------
   //	Calculation of target quaternion for ground station pointing
   //-------------------------------------------------------------------------------------
   // transform longitude, latitude and altitude to cartesian coordiantes (ECEF)
   double posGroundStationF[3] = {0, 0, 0};
-  MathOperations<double>::cartesianFromLatLongAlt(
+  CoordinateTransformations::cartesianFromLatLongAlt(
       acsParameters->gsTargetModeControllerParameters.latitudeTgt,
       acsParameters->gsTargetModeControllerParameters.longitudeTgt,
       acsParameters->gsTargetModeControllerParameters.altitudeTgt, posGroundStationF);
@@ -106,43 +105,93 @@ void Guidance::targetQuatPtgGs(timeval timeAbsolute, const double timeDelta, dou
   // target direction in the ECI frame
   double posSatI[3] = {0, 0, 0}, posGroundStationI[3] = {0, 0, 0}, groundStationDirI[3] = {0, 0, 0};
   CoordinateTransformations::positionEcfToEci(posSatF, posSatI, &timeAbsolute);
-  CoordinateTransformations::positionEcfToEci(posGroundStationI, posGroundStationI, &timeAbsolute);
+  CoordinateTransformations::positionEcfToEci(posGroundStationF, posGroundStationI, &timeAbsolute);
   VectorOperations<double>::subtract(posGroundStationI, posSatI, groundStationDirI, 3);
 
   // negative x-axis aligned with target direction
   // this aligns with the camera, E- and S-band antennas
-  double xAxisXI[3] = {0, 0, 0};
-  VectorOperations<double>::normalize(groundStationDirI, xAxisXI, 3);
-  VectorOperations<double>::mulScalar(xAxisXI, -1, xAxisXI, 3);
+  double xAxisIX[3] = {0, 0, 0};
+  VectorOperations<double>::normalize(groundStationDirI, xAxisIX, 3);
+  VectorOperations<double>::mulScalar(xAxisIX, -1, xAxisIX, 3);
 
-  // get sun vector model in ECI
-  VectorOperations<double>::normalize(sunDirI, sunDirI, 3);
+  // get earth vector in ECI
+  double earthDirI[3] = {0, 0, 0};
+  VectorOperations<double>::normalize(posSatI, earthDirI, 3);
+  VectorOperations<double>::mulScalar(earthDirI, -1, earthDirI, 3);
 
-  // calculate z-axis as projection of sun vector into plane defined by x-axis as normal vector
-  // z = sPerpenticular =  s - sParallel = s - (x*s)/norm(x)^2 * x
-  double xDotS = VectorOperations<double>::dot(xAxisXI, sunDirI);
-  xDotS /= pow(VectorOperations<double>::norm(xAxisXI, 3), 2);
-  double sunParallel[3], zAxisXI[3];
-  VectorOperations<double>::mulScalar(xAxisXI, xDotS, sunParallel, 3);
-  VectorOperations<double>::subtract(sunDirI, sunParallel, zAxisXI, 3);
-  VectorOperations<double>::normalize(zAxisXI, zAxisXI, 3);
+  // sun avoidance calculations
+  double sunPerpendicularX[3] = {0, 0, 0}, sunFloorYZ[3] = {0, 0, 0}, zAxisSun[3] = {0, 0, 0};
+  VectorOperations<double>::mulScalar(xAxisIX, VectorOperations<double>::dot(xAxisIX, sunDirI),
+                                      sunPerpendicularX, 3);
+  VectorOperations<double>::subtract(sunDirI, sunPerpendicularX, sunFloorYZ, 3);
+  VectorOperations<double>::normalize(sunFloorYZ, sunFloorYZ, 3);
+  VectorOperations<double>::mulScalar(sunFloorYZ, -1, zAxisSun, 3);
+  double sunWeight = 0, strVecSun[3] = {0, 0, 0}, strVecSunX[3] = {0, 0, 0},
+         strVecSunZ[3] = {0, 0, 0};
+  VectorOperations<double>::mulScalar(xAxisIX, acsParameters->strParameters.boresightAxis[0],
+                                      strVecSunX, 3);
+  VectorOperations<double>::mulScalar(zAxisSun, acsParameters->strParameters.boresightAxis[2],
+                                      strVecSunZ, 3);
+  VectorOperations<double>::add(strVecSunX, strVecSunZ, strVecSun, 3);
+  VectorOperations<double>::normalize(strVecSun, strVecSun, 3);
+  sunWeight = VectorOperations<double>::dot(strVecSun, sunDirI);
 
-  // y-axis completes RHS
-  double yAxisXI[3];
-  VectorOperations<double>::cross(zAxisXI, xAxisXI, yAxisXI);
-  VectorOperations<double>::normalize(yAxisXI, yAxisXI, 3);
+  // earth avoidance calculations
+  double earthPerpendicularX[3] = {0, 0, 0}, earthFloorYZ[3] = {0, 0, 0}, zAxisEarth[3] = {0, 0, 0};
+  VectorOperations<double>::mulScalar(xAxisIX, VectorOperations<double>::dot(xAxisIX, earthDirI),
+                                      earthPerpendicularX, 3);
+  VectorOperations<double>::subtract(earthDirI, earthPerpendicularX, earthFloorYZ, 3);
+  VectorOperations<double>::normalize(earthFloorYZ, earthFloorYZ, 3);
+  VectorOperations<double>::mulScalar(earthFloorYZ, -1, zAxisEarth, 3);
+  double earthWeight = 0, strVecEarth[3] = {0, 0, 0}, strVecEarthX[3] = {0, 0, 0},
+         strVecEarthZ[3] = {0, 0, 0};
+  VectorOperations<double>::mulScalar(xAxisIX, acsParameters->strParameters.boresightAxis[0],
+                                      strVecEarthX, 3);
+  VectorOperations<double>::mulScalar(zAxisEarth, acsParameters->strParameters.boresightAxis[2],
+                                      strVecEarthZ, 3);
+  VectorOperations<double>::add(strVecEarthX, strVecEarthZ, strVecEarth, 3);
+  VectorOperations<double>::normalize(strVecEarth, strVecEarth, 3);
+  earthWeight = VectorOperations<double>::dot(strVecEarth, earthDirI);
+
+  if ((sunWeight == 0.0) and (earthWeight == 0.0)) {
+    // if this actually ever happens i will eat a broom
+    sunWeight = 0.5;
+    earthWeight = 0.5;
+  }
+
+  // normalize weights for convenience
+  double normFactor = 1. / (std::abs(sunWeight) + std::abs(earthWeight));
+  sunWeight *= normFactor;
+  earthWeight *= normFactor;
+
+  // calculate z-axis for str blinding avoidance
+  double zAxisIX[3] = {0, 0, 0};
+  VectorOperations<double>::mulScalar(zAxisSun, sunWeight, zAxisSun, 3);
+  VectorOperations<double>::mulScalar(zAxisEarth, earthWeight, zAxisEarth, 3);
+  VectorOperations<double>::add(zAxisSun, zAxisEarth, zAxisIX, 3);
+  VectorOperations<double>::mulScalar(zAxisIX, -1, zAxisIX, 3);
+  VectorOperations<double>::normalize(zAxisIX, zAxisIX, 3);
+
+  // calculate y-axis
+  double yAxisIX[3] = {0, 0, 0};
+  VectorOperations<double>::cross(zAxisIX, xAxisIX, yAxisIX);
+  VectorOperations<double>::normalize(yAxisIX, yAxisIX, 3);
 
   // join transformation matrix
-  double dcmXI[3][3] = {{xAxisXI[0], yAxisXI[0], zAxisXI[0]},
-                        {xAxisXI[1], yAxisXI[1], zAxisXI[1]},
-                        {xAxisXI[2], yAxisXI[2], zAxisXI[2]}};
-  QuaternionOperations::fromDcm(dcmXI, targetQuat);
+  double dcmIX[3][3] = {{xAxisIX[0], yAxisIX[0], zAxisIX[0]},
+                        {xAxisIX[1], yAxisIX[1], zAxisIX[1]},
+                        {xAxisIX[2], yAxisIX[2], zAxisIX[2]}};
+  QuaternionOperations::fromDcm(dcmIX, targetQuat);
 
+  limitReferenceRotation(xAxisIX, targetQuat);
   targetRotationRate(timeDelta, targetQuat, targetSatRotRate);
+
+  std::memcpy(xAxisIXprev, xAxisIX, sizeof(xAxisIXprev));
 }
 
-void Guidance::targetQuatPtgNadir(timeval timeAbsolute, const double timeDelta, double posSatE[3],
-                                  double velSatE[3], double targetQuat[4], double refSatRate[3]) {
+void Guidance::targetQuatPtgNadir(timeval timeAbsolute, const double timeDelta,
+                                  const double posSatE[3], const double velSatE[3],
+                                  double targetQuat[4], double refSatRate[3]) {
   //-------------------------------------------------------------------------------------
   //	Calculation of target quaternion for Nadir pointing
   //-------------------------------------------------------------------------------------
@@ -153,26 +202,26 @@ void Guidance::targetQuatPtgNadir(timeval timeAbsolute, const double timeDelta,
 
   // negative x-axis aligned with position vector
   // this aligns with the camera, E- and S-band antennas
-  double xAxisXI[3] = {0, 0, 0};
-  VectorOperations<double>::normalize(posSatI, xAxisXI, 3);
-  VectorOperations<double>::mulScalar(xAxisXI, -1, xAxisXI, 3);
+  double xAxisIX[3] = {0, 0, 0};
+  VectorOperations<double>::normalize(posSatI, xAxisIX, 3);
+  VectorOperations<double>::mulScalar(xAxisIX, -1, xAxisIX, 3);
 
   // make z-Axis parallel to major part of camera resolution
-  double zAxisXI[3] = {0, 0, 0};
+  double zAxisIX[3] = {0, 0, 0};
   double velSatI[3] = {0, 0, 0};
   CoordinateTransformations::velocityEcfToEci(velSatE, posSatE, velSatI, &timeAbsolute);
-  VectorOperations<double>::cross(xAxisXI, velSatI, zAxisXI);
-  VectorOperations<double>::normalize(zAxisXI, zAxisXI, 3);
+  VectorOperations<double>::cross(xAxisIX, velSatI, zAxisIX);
+  VectorOperations<double>::normalize(zAxisIX, zAxisIX, 3);
 
   // y-Axis completes RHS
-  double yAxisXI[3] = {0, 0, 0};
-  VectorOperations<double>::cross(zAxisXI, xAxisXI, yAxisXI);
+  double yAxisIX[3] = {0, 0, 0};
+  VectorOperations<double>::cross(zAxisIX, xAxisIX, yAxisIX);
 
   // join transformation matrix
-  double dcmXI[3][3] = {{xAxisXI[0], yAxisXI[0], zAxisXI[0]},
-                        {xAxisXI[1], yAxisXI[1], zAxisXI[1]},
-                        {xAxisXI[2], yAxisXI[2], zAxisXI[2]}};
-  QuaternionOperations::fromDcm(dcmXI, targetQuat);
+  double dcmIX[3][3] = {{xAxisIX[0], yAxisIX[0], zAxisIX[0]},
+                        {xAxisIX[1], yAxisIX[1], zAxisIX[1]},
+                        {xAxisIX[2], yAxisIX[2], zAxisIX[2]}};
+  QuaternionOperations::fromDcm(dcmIX, targetQuat);
 
   targetRotationRate(timeDelta, targetQuat, refSatRate);
 }
@@ -183,12 +232,72 @@ void Guidance::targetRotationRate(const double timeDelta, double quatIX[4], doub
   }
   if (timeDelta != 0.0) {
     QuaternionOperations::rotationFromQuaternions(quatIX, quatIXprev, timeDelta, refSatRate);
+    VectorOperations<double>::mulScalar(refSatRate, -1, refSatRate, 3);
   } else {
     std::memcpy(refSatRate, ZERO_VEC3, 3 * sizeof(double));
   }
   std::memcpy(quatIXprev, quatIX, sizeof(quatIXprev));
 }
 
+void Guidance::limitReferenceRotation(const double xAxisIX[3], double quatIX[4]) {
+  if ((VectorOperations<double>::norm(quatIXprev, 4) == 0) or
+      (VectorOperations<double>::norm(xAxisIXprev, 3) == 0)) {
+    return;
+  }
+
+  QuaternionOperations::preventSignJump(quatIX, quatIXprev);
+
+  // check required rotation and return if below limit
+  double quatXprevX[4] = {0, 0, 0, 0}, quatXprevI[4] = {0, 0, 0, 0};
+  QuaternionOperations::inverse(quatIXprev, quatXprevI);
+  QuaternionOperations::multiply(quatIX, quatXprevI, quatXprevX);
+  QuaternionOperations::normalize(quatXprevX);
+  double phiMax = acsParameters->gsTargetModeControllerParameters.rotRateLimit *
+                  acsParameters->onBoardParams.sampleTime;
+  if (2 * std::acos(quatXprevX[3]) < phiMax) {
+    return;
+  }
+
+  // x-axis always needs full rotation
+  double phiX = 0, phiXvec[3] = {0, 0, 0};
+  phiX = std::acos(VectorOperations<double>::dot(xAxisIXprev, xAxisIX));
+  VectorOperations<double>::cross(xAxisIXprev, xAxisIX, phiXvec);
+  VectorOperations<double>::normalize(phiXvec, phiXvec, 3);
+
+  double quatXprevXtilde[4] = {0, 0, 0, 0}, quatIXtilde[4] = {0, 0, 0, 0};
+  VectorOperations<double>::mulScalar(phiXvec, -std::sin(phiX / 2.), phiXvec, 3);
+  std::memcpy(quatXprevXtilde, phiXvec, sizeof(phiXvec));
+  quatXprevXtilde[3] = cos(phiX / 2.);
+  QuaternionOperations::normalize(quatXprevXtilde);
+  QuaternionOperations::multiply(quatXprevXtilde, quatIXprev, quatIXtilde);
+
+  // use the residual rotation up to the maximum
+  double quatXXtilde[4] = {0, 0, 0, 0}, quatXI[4] = {0, 0, 0, 0};
+  QuaternionOperations::inverse(quatIX, quatXI);
+  QuaternionOperations::multiply(quatIXtilde, quatXI, quatXXtilde);
+
+  double phiResidual = 0, phiResidualVec[3] = {0, 0, 0};
+  if ((phiX * phiX) > (phiMax * phiMax)) {
+    phiResidual = 0;
+  } else {
+    phiResidual = std::sqrt((phiMax * phiMax) - (phiX * phiX));
+  }
+  std::memcpy(phiResidualVec, quatXXtilde, sizeof(phiResidualVec));
+  VectorOperations<double>::normalize(phiResidualVec, phiResidualVec, 3);
+
+  double quatXhatXTilde[4] = {0, 0, 0, 0}, quatXTildeXhat[4] = {0, 0, 0, 0};
+  VectorOperations<double>::mulScalar(phiResidualVec, std::sin(phiResidual / 2.), phiResidualVec,
+                                      3);
+  std::memcpy(quatXhatXTilde, phiResidualVec, sizeof(phiResidualVec));
+  quatXhatXTilde[3] = std::cos(phiResidual / 2.);
+  QuaternionOperations::normalize(quatXhatXTilde);
+
+  // calculate final quaternion
+  QuaternionOperations::inverse(quatXhatXTilde, quatXTildeXhat);
+  QuaternionOperations::multiply(quatXTildeXhat, quatIXtilde, quatIX);
+  QuaternionOperations::normalize(quatIX);
+}
+
 void Guidance::comparePtg(double currentQuat[4], double currentSatRotRate[3], double targetQuat[4],
                           double targetSatRotRate[3], double refQuat[4], double refSatRotRate[3],
                           double errorQuat[4], double errorSatRotRate[3], double &errorAngle) {
@@ -207,9 +316,9 @@ void Guidance::comparePtg(double currentQuat[4], double currentSatRotRate[3], do
 
   // Calculate error satellite rotational rate
   // Convert target rotational rate into body RF
-  double errorQuatInv[4] = {0, 0, 0, 0}, targetSatRotRateB[3] = {0, 0, 0};
-  QuaternionOperations::inverse(errorQuat, errorQuatInv);
-  QuaternionOperations::multiplyVector(errorQuatInv, targetSatRotRate, targetSatRotRateB);
+  double targetSatRotRateB[3] = {0, 0, 0};
+  QuaternionOperations::multiplyVector(currentQuat, targetSatRotRate, targetSatRotRateB);
+  VectorOperations<double>::copy(targetSatRotRateB, targetSatRotRate, 3);
   // Combine the target and reference satellite rotational rates
   double combinedRefSatRotRate[3] = {0, 0, 0};
   VectorOperations<double>::add(targetSatRotRate, refSatRotRate, combinedRefSatRotRate, 3);
@@ -226,28 +335,32 @@ void Guidance::comparePtg(double currentQuat[4], double currentSatRotRate[3], do
 }
 
 ReturnValue_t Guidance::getDistributionMatrixRw(ACS::SensorValues *sensorValues,
-                                                double *rwPseudoInv) {
-  bool rw1valid = (sensorValues->rw1Set.state.value and sensorValues->rw1Set.state.isValid());
-  bool rw2valid = (sensorValues->rw2Set.state.value and sensorValues->rw2Set.state.isValid());
-  bool rw3valid = (sensorValues->rw3Set.state.value and sensorValues->rw3Set.state.isValid());
-  bool rw4valid = (sensorValues->rw4Set.state.value and sensorValues->rw4Set.state.isValid());
+                                                double *rwPseudoInv, acsctrl::RwAvail *rwAvail) {
+  rwAvail->rw1avail = (sensorValues->rw1Set.state.value and sensorValues->rw1Set.state.isValid());
+  rwAvail->rw2avail = (sensorValues->rw2Set.state.value and sensorValues->rw2Set.state.isValid());
+  rwAvail->rw3avail = (sensorValues->rw3Set.state.value and sensorValues->rw3Set.state.isValid());
+  rwAvail->rw4avail = (sensorValues->rw4Set.state.value and sensorValues->rw4Set.state.isValid());
 
-  if (rw1valid and rw2valid and rw3valid and rw4valid) {
+  if (rwAvail->rw1avail and rwAvail->rw2avail and rwAvail->rw3avail and rwAvail->rw4avail) {
     std::memcpy(rwPseudoInv, acsParameters->rwMatrices.pseudoInverse, 12 * sizeof(double));
     return returnvalue::OK;
-  } else if (not rw1valid and rw2valid and rw3valid and rw4valid) {
+  } else if (not rwAvail->rw1avail and rwAvail->rw2avail and rwAvail->rw3avail and
+             rwAvail->rw4avail) {
     std::memcpy(rwPseudoInv, acsParameters->rwMatrices.pseudoInverseWithoutRW1,
                 12 * sizeof(double));
     return acsctrl::SINGLE_RW_UNAVAILABLE;
-  } else if (rw1valid and not rw2valid and rw3valid and rw4valid) {
+  } else if (rwAvail->rw1avail and not rwAvail->rw2avail and rwAvail->rw3avail and
+             rwAvail->rw4avail) {
     std::memcpy(rwPseudoInv, acsParameters->rwMatrices.pseudoInverseWithoutRW2,
                 12 * sizeof(double));
     return acsctrl::SINGLE_RW_UNAVAILABLE;
-  } else if (rw1valid and rw2valid and not rw3valid and rw4valid) {
+  } else if (rwAvail->rw1avail and rwAvail->rw2avail and not rwAvail->rw3avail and
+             rwAvail->rw4avail) {
     std::memcpy(rwPseudoInv, acsParameters->rwMatrices.pseudoInverseWithoutRW3,
                 12 * sizeof(double));
     return acsctrl::SINGLE_RW_UNAVAILABLE;
-  } else if (rw1valid and rw2valid and rw3valid and not rw4valid) {
+  } else if (rwAvail->rw1avail and rwAvail->rw2avail and rwAvail->rw3avail and
+             not rwAvail->rw4avail) {
     std::memcpy(rwPseudoInv, acsParameters->rwMatrices.pseudoInverseWithoutRW4,
                 12 * sizeof(double));
     return acsctrl::SINGLE_RW_UNAVAILABLE;
@@ -255,7 +368,10 @@ ReturnValue_t Guidance::getDistributionMatrixRw(ACS::SensorValues *sensorValues,
   return acsctrl::MULTIPLE_RW_UNAVAILABLE;
 }
 
-void Guidance::resetValues() { std::memcpy(quatIXprev, ZERO_VEC4, sizeof(quatIXprev)); }
+void Guidance::resetValues() {
+  std::memcpy(quatIXprev, ZERO_VEC4, sizeof(quatIXprev));
+  std::memcpy(xAxisIXprev, ZERO_VEC3, sizeof(xAxisIXprev));
+}
 
 void Guidance::getTargetParamsSafe(double sunTargetSafe[3]) {
   std::error_code e;

mission/controller/acs/Guidance.h

@@ -8,9 +8,7 @@
 #include <fsfw/globalfunctions/math/VectorOperations.h>
 #include <mission/controller/acs/AcsParameters.h>
 #include <mission/controller/acs/SensorValues.h>
-#include <mission/controller/acs/util/MathOperations.h>
 #include <mission/controller/controllerdefinitions/AcsCtrlDefinitions.h>
-#include <time.h>
 
 #include <cmath>
 #include <filesystem>
@@ -27,16 +25,18 @@ class Guidance {
 
   void targetQuatPtgIdle(timeval timeAbsolute, const double timeDelta, const double sunDirI[3],
                          const double posSatF[4], double targetQuat[4], double targetSatRotRate[3]);
-  void targetQuatPtgTarget(timeval timeAbsolute, const double timeDelta, double posSatF[3],
-                           double velSatE[3], double quatIX[4], double targetSatRotRate[3]);
-  void targetQuatPtgGs(timeval timeAbsolute, const double timeDelta, double posSatF[3],
-                       double sunDirI[3], double quatIX[4], double targetSatRotRate[3]);
-  void targetQuatPtgNadir(timeval timeAbsolute, const double timeDelta, double posSatF[3],
-                          double velSatF[3], double targetQuat[4], double refSatRate[3]);
+  void targetQuatPtgTarget(timeval timeAbsolute, const double timeDelta, const double posSatF[3],
+                           const double velSatE[3], double quatIX[4], double targetSatRotRate[3]);
+  void targetQuatPtgGs(timeval timeAbsolute, const double timeDelta, const double posSatF[3],
+                       const double sunDirI[3], double quatIX[4], double targetSatRotRate[3]);
+  void targetQuatPtgNadir(timeval timeAbsolute, const double timeDelta, const double posSatF[3],
+                          const double velSatF[3], double targetQuat[4], double refSatRate[3]);
 
   void targetRotationRate(const double timeDelta, double quatInertialTarget[4],
                           double *targetSatRotRate);
 
+  void limitReferenceRotation(const double xAxisIX[3], double quatIX[4]);
+
   void comparePtg(double currentQuat[4], double currentSatRotRate[3], double targetQuat[4],
                   double targetSatRotRate[3], double refQuat[4], double refSatRotRate[3],
                   double errorQuat[4], double errorSatRotRate[3], double &errorAngle);
@@ -44,7 +44,8 @@ class Guidance {
                   double targetSatRotRate[3], double errorQuat[4], double errorSatRotRate[3],
                   double &errorAngle);
 
-  ReturnValue_t getDistributionMatrixRw(ACS::SensorValues *sensorValues, double *rwPseudoInv);
+  ReturnValue_t getDistributionMatrixRw(ACS::SensorValues *sensorValues, double *rwPseudoInv,
+                                        acsctrl::RwAvail *rwAvail);
 
  private:
   const AcsParameters *acsParameters;
@@ -54,6 +55,7 @@ class Guidance {
 
   bool strBlindAvoidFlag = false;
   double quatIXprev[4] = {0, 0, 0, 0};
+  double xAxisIXprev[3] = {0, 0, 0};
 
   static constexpr char SD_0_SKEWED_PTG_FILE[] = "/mnt/sd0/conf/acsDeploymentConfirm";
   static constexpr char SD_1_SKEWED_PTG_FILE[] = "/mnt/sd1/conf/acsDeploymentConfirm";

mission/controller/acs/Igrf13Model.cpp

@@ -1,19 +1,5 @@
 #include "Igrf13Model.h"
 
-#include <fsfw/src/fsfw/globalfunctions/constants.h>
-#include <fsfw/src/fsfw/globalfunctions/math/MatrixOperations.h>
-#include <fsfw/src/fsfw/globalfunctions/math/QuaternionOperations.h>
-#include <fsfw/src/fsfw/globalfunctions/math/VectorOperations.h>
-#include <stdint.h>
-#include <string.h>
-#include <time.h>
-
-#include <cmath>
-
-#include "util/MathOperations.h"
-
-using namespace Math;
-
 Igrf13Model::Igrf13Model() {}
 Igrf13Model::~Igrf13Model() {}
 
@@ -23,7 +9,7 @@ void Igrf13Model::magFieldComp(const double longitude, const double gcLatitude,
   double magFieldModel[3] = {0, 0, 0};
   double phi = longitude, theta = gcLatitude;  // geocentric
   /* Here is the co-latitude needed*/
-  theta -= 90 * PI / 180;
+  theta -= 90. * M_PI / 180.;
   theta *= (-1);
 
   double rE = 6371200.0;  // radius earth [m]
@@ -83,13 +69,14 @@ void Igrf13Model::magFieldComp(const double longitude, const double gcLatitude,
   magFieldModel[1] *= -1;
   magFieldModel[2] *= (-1 / sin(theta));
 
-  double JD2000 = MathOperations<double>::convertUnixToJD2000(timeOfMagMeasurement);
+  double JD2000 = 0;
+  Clock::convertTimevalToJD2000(timeOfMagMeasurement, &JD2000);
   double UT1 = JD2000 / 36525.;
 
   double gst =
       280.46061837 + 360.98564736629 * JD2000 + 0.0003875 * pow(UT1, 2) - 2.6e-8 * pow(UT1, 3);
   gst = std::fmod(gst, 360.);
-  gst *= PI / 180.;
+  gst *= M_PI / 180.;
   double lst = gst + longitude;  // local sidereal time [rad]
 
   magFieldModelInertial[0] =
@@ -107,7 +94,8 @@ void Igrf13Model::magFieldComp(const double longitude, const double gcLatitude,
 
 void Igrf13Model::updateCoeffGH(timeval timeOfMagMeasurement) {
   double JD2000Igrf = (2458850.0 - 2451545);  // Begin of IGRF-13 (2020-01-01,00:00:00) in JD2000
-  double JD2000 = MathOperations<double>::convertUnixToJD2000(timeOfMagMeasurement);
+  double JD2000 = 0;
+  Clock::convertTimevalToJD2000(timeOfMagMeasurement, &JD2000);
   double days = ceil(JD2000 - JD2000Igrf);
   for (int i = 0; i <= igrfOrder; i++) {
     for (int j = 0; j <= (igrfOrder - 1); j++) {

mission/controller/acs/Igrf13Model.h

@@ -16,10 +16,11 @@
 #ifndef IGRF13MODEL_H_
 #define IGRF13MODEL_H_
 
-#include <fsfw/parameters/HasParametersIF.h>
-#include <stdint.h>
-#include <string.h>
-#include <time.h>
+#include <fsfw/src/fsfw/globalfunctions/constants.h>
+#include <fsfw/src/fsfw/globalfunctions/math/MatrixOperations.h>
+#include <fsfw/src/fsfw/globalfunctions/math/QuaternionOperations.h>
+#include <fsfw/src/fsfw/globalfunctions/math/VectorOperations.h>
+#include <fsfw/src/fsfw/timemanager/Clock.h>
 
 #include <cmath>
 

mission/controller/acs/MultiplicativeKalmanFilter.h

@@ -1,14 +1,16 @@
 #ifndef MULTIPLICATIVEKALMANFILTER_H_
 #define MULTIPLICATIVEKALMANFILTER_H_
 
-#include <stdint.h>
-
-#include "../controllerdefinitions/AcsCtrlDefinitions.h"
-#include "AcsParameters.h"
-#include "eive/resultClassIds.h"
+#include <common/config/eive/resultClassIds.h>
+#include <fsfw/globalfunctions/math/MatrixOperations.h>
+#include <fsfw/globalfunctions/math/QuaternionOperations.h>
+#include <fsfw/globalfunctions/math/VectorOperations.h>
+#include <mission/controller/acs/AcsParameters.h>
+#include <mission/controller/acs/SensorValues.h>
+#include <mission/controller/controllerdefinitions/AcsCtrlDefinitions.h>
 
 class MultiplicativeKalmanFilter {
-  /* @brief: This class handles the calculation of an estimated quaternion and the gyro bias by
+  /* @brief: This class handles the calculation of an estimated quaternion and the gyroscope bias by
    *           means of the spacecraft attitude sensors
    *
    * @note: A description of the used algorithms can be found in the bachelor thesis of Robin
@@ -18,56 +20,26 @@ class MultiplicativeKalmanFilter {
  public:
   /* @brief: Constructor
    */
-  MultiplicativeKalmanFilter();
+  MultiplicativeKalmanFilter(AcsParameters *acsParameters);
   virtual ~MultiplicativeKalmanFilter();
 
-  ReturnValue_t reset(acsctrl::AttitudeEstimationData *mekfData);
+  ReturnValue_t reset(acsctrl::AttitudeEstimationData *attitudeEstimationData);
 
-  /* @brief: init() - This function initializes the Kalman Filter and will provide the first
-   * quaternion through the QUEST algorithm
-   * @param:  magneticField_  magnetic field vector in the body frame
-   * 		  sunDir_ 		  sun direction vector in the body frame
-   * 		  sunDirJ 		  sun direction vector in the ECI frame
-   * 		  magFieldJ 	  magnetic field vector in the ECI frame
-   */
-  ReturnValue_t init(const double *magneticField_, const bool validMagField_, const double *sunDir_,
-                     const bool validSS, const double *sunDirJ, const bool validSSModel,
-                     const double *magFieldJ, const bool validMagModel,
-                     acsctrl::AttitudeEstimationData *mekfData, AcsParameters *acsParameters);
+  ReturnValue_t init(const acsctrl::SusDataProcessed *susData,
+                     const acsctrl::MgmDataProcessed *mgmData,
+                     const acsctrl::GyrDataProcessed *gyrData,
+                     acsctrl::AttitudeEstimationData *attitudeEstimationData);
 
-  /* @brief:  mekfEst() - This function calculates the quaternion and gyro bias of the Kalman Filter
-   * for the current step after the initalization
-   * @param:  quaternionSTR   Star Tracker Quaternion between from body to ECI frame
-   * 			rateGYRs_ 		Estimated satellite rotation rate from the
-   * Gyroscopes [rad/s] magneticField_  magnetic field vector in the body frame sunDir_
-   * sun direction vector in the body frame sunDirJ 		sun direction vector in the ECI
-   * frame magFieldJ 		magnetic field vector in the ECI frame
-   * 			outputQuat 		Stores the calculated quaternion
-   * 			outputSatRate 	Stores the adjusted satellite rate
-   * @return 	ReturnValue_t	Feedback of this class, KALMAN_NO_GYR_MEAS if no satellite rate from
-   * the sensors was provided, KALMAN_NO_MODEL if no sunDirJ or magFieldJ was given from the model
-   * calculations, KALMAN_INVERSION_FAILED if the calculation of the Gain matrix was not possible,
-   * 							RETURN_OK else
-   */
-  ReturnValue_t mekfEst(const double *quaternionSTR, const bool validSTR_, const double *rateGYRs_,
-                        const bool validGYRs_, const double *magneticField_,
-                        const bool validMagField_, const double *sunDir_, const bool validSS,
-                        const double *sunDirJ, const bool validSSModel, const double *magFieldJ,
-                        const bool validMagModel, acsctrl::AttitudeEstimationData *mekfData,
-                        AcsParameters *acsParameters);
+  ReturnValue_t mekfEst(const acsctrl::SusDataProcessed *susData,
+                        const acsctrl::MgmDataProcessed *mgmData,
+                        const acsctrl::GyrDataProcessed *gyrData, const double timeDelta,
+                        acsctrl::AttitudeEstimationData *attitudeEstimationData);
 
-  enum MekfStatus : uint8_t {
-    UNINITIALIZED = 0,
-    NO_GYR_DATA = 1,
-    NO_MODEL_VECTORS = 2,
-    NO_SUS_MGM_STR_DATA = 3,
-    COVARIANCE_INVERSION_FAILED = 4,
-    NOT_FINITE = 5,
-    INITIALIZED = 10,
-    RUNNING = 11,
-  };
+  void updateStandardDeviations(const AcsParameters *acsParameters);
+
+  void setStrData(const double qX, const double qY, const double qZ, const double qW,
+                  const bool valid, const bool allowStr);
 
-  // resetting Mekf
   static constexpr uint8_t IF_MEKF_ID = CLASS_ID::ACS_MEKF;
   static constexpr ReturnValue_t MEKF_UNINITIALIZED = returnvalue::makeCode(IF_MEKF_ID, 2);
   static constexpr ReturnValue_t MEKF_NO_GYR_DATA = returnvalue::makeCode(IF_MEKF_ID, 3);
@@ -82,26 +54,93 @@ class MultiplicativeKalmanFilter {
  private:
   static constexpr double ZERO_VEC3[3] = {0, 0, 0};
   static constexpr double ZERO_VEC4[4] = {0, 0, 0, 0};
-
-  /*Parameters*/
-  double quaternion_STR_SB[4];
-
-  /*States*/
-  double initialQuaternion[4] = {0, 0, 0, 1}; /*after reset?QUEST*/
-  double initialCovarianceMatrix[6][6] = {{0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0},
+  static constexpr double ZERO_MAT66[6][6] = {{0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0},
                                               {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0},
                                               {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}};
-  double propagatedQuaternion[4]; /*Filter Quaternion for next step*/
-  uint8_t sensorsAvail = 0;
+  static constexpr double UNIT_QUAT[4] = {0, 0, 0, 1};
+  static constexpr double EYE3[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
+  static constexpr double EYE6[6][6] = {{1, 0, 0, 0, 0, 0}, {0, 1, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0},
+                                        {0, 0, 0, 1, 0, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 0, 1}};
 
-  /*Outputs*/
-  double quatBJ[4];  /* Output Quaternion */
-  double biasGYR[3]; /*Between measured and estimated sat Rate*/
-                     /*Parameter INIT*/
-  /*Functions*/
-  void updateDataSetWithoutData(acsctrl::AttitudeEstimationData *mekfData, MekfStatus mekfStatus);
-  void updateDataSet(acsctrl::AttitudeEstimationData *mekfData, MekfStatus mekfStatus,
-                     double quat[4], double satRotRate[3]);
+  enum MekfStatus : uint8_t {
+    UNINITIALIZED = 0,
+    NO_GYR_DATA = 1,
+    NO_MODEL_VECTORS = 2,
+    NO_SUS_MGM_STR_DATA = 3,
+    COVARIANCE_INVERSION_FAILED = 4,
+    NOT_FINITE = 5,
+    INITIALIZED = 10,
+    RUNNING = 11,
+  };
+
+  enum SensorAvailability : uint8_t {
+    NONE = 0,
+    SUS_MGM_STR = 1,
+    SUS_MGM = 2,
+    SUS_STR = 3,
+    MGM_STR = 4,
+    SUS = 5,
+    MGM = 6,
+    STR = 7,
+  };
+
+  MekfStatus mekfStatus = MekfStatus::UNINITIALIZED;
+
+  struct StrData {
+    struct StrQuat {
+      double value[4] = {0, 0, 0, 0};
+      bool valid = false;
+    } strQuat;
+  } strData;
+
+  // Standard Deviations
+  double sigmaSus = 0;
+  double sigmaMgm = 0;
+  double sigmaStr = 0;
+  double sigmaGyr = 0;
+  // sigmaV
+  double sigmaGyrArw = 0;
+  // sigmaU
+  double sigmaGyrBs = 0;
+
+  // Covariance Matrices
+  double covSus[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  double covMgm[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+  double covStr[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
+
+  double covAposteriori[6][6] = {{0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0},
+                                 {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}};
+
+  // Sensor Availability
+  SensorAvailability sensorsAvailable = SensorAvailability::NONE;
+  uint8_t matrixDimensionFactor = 0;
+
+  // Estimated States
+  double estimatedQuaternionBI[4] = {0, 0, 0, 1};
+  double estimatedBiasGyr[3] = {0, 0, 0};
+  double estimatedRotRate[3] = {0, 0, 0};
+  double estimatedCovarianceMatrix[6][6] = {{0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0},
+                                            {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0},
+                                            {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}};
+
+  // Functions
+  ReturnValue_t checkAvailableSensors(const acsctrl::SusDataProcessed *susData,
+                                      const acsctrl::MgmDataProcessed *mgmData,
+                                      const acsctrl::GyrDataProcessed *gyrData,
+                                      acsctrl::AttitudeEstimationData *attitudeEstimationData);
+
+  void kfUpdate(const acsctrl::SusDataProcessed *susData, const acsctrl::MgmDataProcessed *mgmData,
+                double *measSensMatrix, double *measCovMatrix, double *measVec, double *measEstVec);
+  ReturnValue_t kfGain(double *measSensMatrix, double *measCovMatrix, double *kalmanGain,
+                       acsctrl::AttitudeEstimationData *attitudeEstimationData);
+  void kfCovAposteriori(double *kalmanGain, double *measSensMatrix);
+  void kfStateAposteriori(double *kalmanGain, double *measVec, double *estVec);
+  void kfPropagate(const acsctrl::GyrDataProcessed *gyrData, const double timeDiff);
+
+  ReturnValue_t kfFiniteCheck(acsctrl::AttitudeEstimationData *attitudeEstimationData);
+
+  void updateDataSetWithoutData(acsctrl::AttitudeEstimationData *attitudeEstimationData);
+  void updateDataSet(acsctrl::AttitudeEstimationData *attitudeEstimationData);
 };
 
 #endif /* ACS_MULTIPLICATIVEKALMANFILTER_H_ */

mission/controller/acs/Navigation.cpp

@@ -1,43 +1,28 @@
 #include "Navigation.h"
 
-#include <fsfw/globalfunctions/math/MatrixOperations.h>
-#include <fsfw/globalfunctions/math/QuaternionOperations.h>
-#include <fsfw/globalfunctions/math/VectorOperations.h>
-#include <math.h>
-
-#include "util/CholeskyDecomposition.h"
-#include "util/MathOperations.h"
-
-Navigation::Navigation() {}
+Navigation::Navigation(AcsParameters *acsParameters) : multiplicativeKalmanFilter(acsParameters) {}
 
 Navigation::~Navigation() {}
 
-ReturnValue_t Navigation::useMekf(ACS::SensorValues *sensorValues,
-                                  acsctrl::GyrDataProcessed *gyrDataProcessed,
-                                  acsctrl::MgmDataProcessed *mgmDataProcessed,
-                                  acsctrl::SusDataProcessed *susDataProcessed,
-                                  acsctrl::AttitudeEstimationData *mekfData,
-                                  AcsParameters *acsParameters) {
-  double quatIB[4] = {sensorValues->strSet.caliQx.value, sensorValues->strSet.caliQy.value,
-                      sensorValues->strSet.caliQz.value, sensorValues->strSet.caliQw.value};
-  bool quatIBValid = sensorValues->strSet.isTrustWorthy.value;
+ReturnValue_t Navigation::useMekf(const ACS::SensorValues *sensorValues,
+                                  const acsctrl::GyrDataProcessed *gyrDataProcessed,
+                                  const acsctrl::MgmDataProcessed *mgmDataProcessed,
+                                  const acsctrl::SusDataProcessed *susDataProcessed,
+                                  const double timeDelta,
+                                  acsctrl::AttitudeEstimationData *attitudeEstimationData,
+                                  const bool allowStr) {
+  multiplicativeKalmanFilter.setStrData(
+      sensorValues->strSet.caliQx.value, sensorValues->strSet.caliQy.value,
+      sensorValues->strSet.caliQz.value, sensorValues->strSet.caliQw.value,
+      sensorValues->strSet.caliQx.isValid(), allowStr);
 
   if (mekfStatus == MultiplicativeKalmanFilter::MEKF_UNINITIALIZED) {
-    mekfStatus = multiplicativeKalmanFilter.init(
-        mgmDataProcessed->mgmVecTot.value, mgmDataProcessed->mgmVecTot.isValid(),
-        susDataProcessed->susVecTot.value, susDataProcessed->susVecTot.isValid(),
-        susDataProcessed->sunIjkModel.value, susDataProcessed->sunIjkModel.isValid(),
-        mgmDataProcessed->magIgrfModel.value, mgmDataProcessed->magIgrfModel.isValid(), mekfData,
-        acsParameters);
+    mekfStatus = multiplicativeKalmanFilter.init(susDataProcessed, mgmDataProcessed,
+                                                 gyrDataProcessed, attitudeEstimationData);
     return mekfStatus;
   } else {
     mekfStatus = multiplicativeKalmanFilter.mekfEst(
-        quatIB, quatIBValid, gyrDataProcessed->gyrVecTot.value,
-        gyrDataProcessed->gyrVecTot.isValid(), mgmDataProcessed->mgmVecTot.value,
-        mgmDataProcessed->mgmVecTot.isValid(), susDataProcessed->susVecTot.value,
-        susDataProcessed->susVecTot.isValid(), susDataProcessed->sunIjkModel.value,
-        susDataProcessed->sunIjkModel.isValid(), mgmDataProcessed->magIgrfModel.value,
-        mgmDataProcessed->magIgrfModel.isValid(), mekfData, acsParameters);
+        susDataProcessed, mgmDataProcessed, gyrDataProcessed, timeDelta, attitudeEstimationData);
     return mekfStatus;
   }
 }
@@ -82,3 +67,7 @@ ReturnValue_t Navigation::useSpg4(timeval now, acsctrl::GpsDataProcessed *gpsDat
 ReturnValue_t Navigation::updateTle(const uint8_t *line1, const uint8_t *line2) {
   return sgp4Propagator.initialize(line1, line2);
 }
+
+void Navigation::updateMekfStandardDeviations(const AcsParameters *acsParameters) {
+  multiplicativeKalmanFilter.updateStandardDeviations(acsParameters);
+}

mission/controller/acs/Navigation.h

@@ -5,24 +5,25 @@
 #include <mission/acs/defs.h>
 #include <mission/controller/acs/AcsParameters.h>
 #include <mission/controller/acs/MultiplicativeKalmanFilter.h>
-#include <mission/controller/acs/SensorProcessing.h>
 #include <mission/controller/acs/SensorValues.h>
 #include <mission/controller/controllerdefinitions/AcsCtrlDefinitions.h>
 
 class Navigation {
  public:
-  Navigation();
+  Navigation(AcsParameters *acsParameters);
   virtual ~Navigation();
 
-  ReturnValue_t useMekf(ACS::SensorValues *sensorValues,
-                        acsctrl::GyrDataProcessed *gyrDataProcessed,
-                        acsctrl::MgmDataProcessed *mgmDataProcessed,
-                        acsctrl::SusDataProcessed *susDataProcessed,
-                        acsctrl::AttitudeEstimationData *mekfData, AcsParameters *acsParameters);
+  ReturnValue_t useMekf(const ACS::SensorValues *sensorValues,
+                        const acsctrl::GyrDataProcessed *gyrDataProcessed,
+                        const acsctrl::MgmDataProcessed *mgmDataProcessed,
+                        const acsctrl::SusDataProcessed *susDataProcessed, const double timeDelta,
+                        acsctrl::AttitudeEstimationData *attitudeEstimationData,
+                        const bool allowStr);
   void resetMekf(acsctrl::AttitudeEstimationData *mekfData);
 
   ReturnValue_t useSpg4(timeval now, acsctrl::GpsDataProcessed *gpsDataProcessed);
   ReturnValue_t updateTle(const uint8_t *line1, const uint8_t *line2);
+  void updateMekfStandardDeviations(const AcsParameters *acsParameters);
 
  protected:
  private:

mission/controller/acs/SensorProcessing.cpp

@@ -180,7 +180,8 @@ void SensorProcessing::processSus(
     const AcsParameters::SunModelParameters *sunModelParameters,
     acsctrl::SusDataProcessed *susDataProcessed) {
   /* -------- Sun Model Direction (IJK frame) ------- */
-  double JD2000 = MathOperations<double>::convertUnixToJD2000(timeAbsolute);
+  double JD2000 = 0;
+  Clock::convertTimevalToJD2000(timeAbsolute, &JD2000);
 
   // Julean Centuries
   double sunIjkModel[3] = {0.0, 0.0, 0.0};
@@ -198,6 +199,7 @@ void SensorProcessing::processSus(
   sunIjkModel[0] = cos(eclipticLongitude);
   sunIjkModel[1] = sin(eclipticLongitude) * cos(epsilon);
   sunIjkModel[2] = sin(eclipticLongitude) * sin(epsilon);
+  VectorOperations<double>::normalize(sunIjkModel, sunIjkModel, 3);
 
   uint64_t susBrightness[12] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
   if (sus0valid) {
@@ -528,8 +530,8 @@ void SensorProcessing::processGps(const double gpsLatitude, const double gpsLong
   uint8_t gpsSource = acs::gps::Source::NONE;
   // We do not trust the GPS and therefore it shall die here if SPG4 is running
   if (gpsDataProcessed->source.value == acs::gps::Source::SPG4 and gpsParameters->useSpg4) {
-    MathOperations<double>::latLongAltFromCartesian(gpsDataProcessed->gpsPosition.value, gdLatitude,
-                                                    gdLongitude, altitude);
+    CoordinateTransformations::latLongAltFromCartesian(gpsDataProcessed->gpsPosition.value,
+                                                       gdLatitude, gdLongitude, altitude);
     double factor = 1 - pow(ECCENTRICITY_WGS84, 2);
     gcLatitude = atan(factor * tan(gdLatitude));
     {
@@ -559,7 +561,7 @@ void SensorProcessing::processGps(const double gpsLatitude, const double gpsLong
 
     // Calculation of the satellite velocity in earth fixed frame
     double deltaDistance[3] = {0, 0, 0};
-    MathOperations<double>::cartesianFromLatLongAlt(latitudeRad, gdLongitude, altitude, posSatE);
+    CoordinateTransformations::cartesianFromLatLongAlt(latitudeRad, gdLongitude, altitude, posSatE);
     if (validSavedPosSatE and timeDelta < (gpsParameters->timeDiffVelocityMax) and timeDelta > 0) {
       VectorOperations<double>::subtract(posSatE, savedPosSatE, deltaDistance, 3);
       VectorOperations<double>::mulScalar(deltaDistance, 1. / timeDelta, gpsVelocityE, 3);

mission/controller/acs/SensorProcessing.h

@@ -2,6 +2,7 @@
 #define SENSORPROCESSING_H_
 
 #include <common/config/eive/resultClassIds.h>
+#include <fsfw/coordinates/CoordinateTransformations.h>
 #include <fsfw/datapool/PoolReadGuard.h>
 #include <fsfw/globalfunctions/constants.h>
 #include <fsfw/globalfunctions/math/MatrixOperations.h>
@@ -9,12 +10,12 @@
 #include <fsfw/globalfunctions/math/VectorOperations.h>
 #include <fsfw/globalfunctions/timevalOperations.h>
 #include <fsfw/returnvalues/returnvalue.h>
+#include <fsfw/timemanager/Clock.h>
 #include <mission/acs/defs.h>
 #include <mission/controller/acs/AcsParameters.h>
 #include <mission/controller/acs/Igrf13Model.h>
 #include <mission/controller/acs/SensorValues.h>
 #include <mission/controller/acs/SusConverter.h>
-#include <mission/controller/acs/util/MathOperations.h>
 #include <mission/controller/controllerdefinitions/AcsCtrlDefinitions.h>
 
 #include <cmath>

mission/controller/acs/SensorValues.h

@@ -4,7 +4,7 @@
 #include <fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h>
 #include <fsfw_hal/devicehandlers/MgmRM3100Handler.h>
 #include <fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.h>
-#include <mission/acs/archive/GPSDefinitions.h>
+#include <linux/acs/GPSDefinitions.h>
 #include <mission/acs/gyroAdisHelpers.h>
 #include <mission/acs/imtqHelpers.h>
 #include <mission/acs/rwHelpers.h>

mission/controller/acs/control/PtgCtrl.cpp

@@ -1,11 +1,5 @@
 #include "PtgCtrl.h"
 
-#include <fsfw/globalfunctions/constants.h>
-#include <fsfw/globalfunctions/math/MatrixOperations.h>
-#include <fsfw/globalfunctions/math/QuaternionOperations.h>
-#include <fsfw/globalfunctions/math/VectorOperations.h>
-#include <fsfw/globalfunctions/sign.h>
-
 PtgCtrl::PtgCtrl(AcsParameters *acsParameters_) { acsParameters = acsParameters_; }
 
 PtgCtrl::~PtgCtrl() {}
@@ -15,10 +9,10 @@ acs::ControlModeStrategy PtgCtrl::pointingCtrlStrategy(
     const bool fusedRateValid, const uint8_t rotRateSource, const uint8_t mekfEnabled) {
   if (not magFieldValid) {
     return acs::ControlModeStrategy::CTRL_NO_MAG_FIELD_FOR_CONTROL;
-  } else if (mekfEnabled and mekfValid) {
-    return acs::ControlModeStrategy::PTGCTRL_MEKF;
   } else if (strValid and fusedRateValid and rotRateSource > acs::rotrate::Source::SUSMGM) {
     return acs::ControlModeStrategy::PTGCTRL_STR;
+  } else if (mekfEnabled and mekfValid) {
+    return acs::ControlModeStrategy::PTGCTRL_MEKF;
   } else if (questValid and fusedRateValid and rotRateSource > acs::rotrate::Source::SUSMGM) {
     return acs::ControlModeStrategy::PTGCTRL_QUEST;
   }
@@ -68,9 +62,9 @@ void PtgCtrl::ptgLaw(AcsParameters::PointingLawParameters *pointingLawParameters
 
   // Inverse of gainMatrix
   double gainMatrixInverse[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-  gainMatrixInverse[0][0] = 1 / gainMatrix[0][0];
-  gainMatrixInverse[1][1] = 1 / gainMatrix[1][1];
-  gainMatrixInverse[2][2] = 1 / gainMatrix[2][2];
+  gainMatrixInverse[0][0] = 1. / gainMatrix[0][0];
+  gainMatrixInverse[1][1] = 1. / gainMatrix[1][1];
+  gainMatrixInverse[2][2] = 1. / gainMatrix[2][2];
 
   double pMatrix[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
   MatrixOperations<double>::multiply(
@@ -146,9 +140,10 @@ void PtgCtrl::ptgNullspace(const bool allRwAvabilable,
                                       4);
 }
 
-void PtgCtrl::ptgDesaturation(AcsParameters::PointingLawParameters *pointingLawParameters,
+void PtgCtrl::ptgDesaturation(const bool allRwAvailable, const acsctrl::RwAvail *rwAvail,
+                              AcsParameters::PointingLawParameters *pointingLawParameters,
                               const double *magFieldB, const bool magFieldBValid,
-                              const double *satRate, const int32_t speedRw0, const int32_t speedRw1,
+                              const int32_t speedRw0, const int32_t speedRw1,
                               const int32_t speedRw2, const int32_t speedRw3, double *mgtDpDes) {
   if (not magFieldBValid or not pointingLawParameters->desatOn) {
     return;
@@ -162,17 +157,24 @@ void PtgCtrl::ptgDesaturation(AcsParameters::PointingLawParameters *pointingLawP
   double magFieldBT[3] = {0, 0, 0};
   VectorOperations<double>::mulScalar(magFieldB, 1e-6, magFieldBT, 3);
 
-  // calculate angular momentum of the satellite
-  double angMomentumSat[3] = {0, 0, 0};
-  MatrixOperations<double>::multiply(*(acsParameters->inertiaEIVE.inertiaMatrixDeployed), satRate,
-                                     angMomentumSat, 3, 3, 1);
-
   // calculate angular momentum of the reaction wheels with respect to the nullspace RW speed
   // relocate RW speed zero to nullspace RW speed
   double refSpeedRws[4] = {0, 0, 0, 0};
   VectorOperations<double>::mulScalar(acsParameters->rwMatrices.nullspaceVector,
                                       pointingLawParameters->nullspaceSpeed, refSpeedRws, 4);
+  if (not allRwAvailable) {
+    if (not rwAvail->rw1avail) {
+      refSpeedRws[0] = 0.0;
+    } else if (not rwAvail->rw2avail) {
+      refSpeedRws[1] = 0.0;
+    } else if (not rwAvail->rw3avail) {
+      refSpeedRws[2] = 0.0;
+    } else if (not rwAvail->rw4avail) {
+      refSpeedRws[3] = 0.0;
+    }
+  }
   VectorOperations<double>::subtract(speedRws, refSpeedRws, speedRws, 4);
+
   // convert speed from 10 RPM to 1 RPM
   VectorOperations<double>::mulScalar(speedRws, 1e-1, speedRws, 4);
   // convert to rad/s
@@ -188,16 +190,12 @@ void PtgCtrl::ptgDesaturation(AcsParameters::PointingLawParameters *pointingLawP
 
   // calculate total angular momentum
   double angMomentumTotal[3] = {0, 0, 0};
-  VectorOperations<double>::add(angMomentumSat, angMomentumRw, angMomentumTotal, 3);
-
-  // calculating momentum error
-  double deltaAngMomentum[3] = {0, 0, 0};
-  VectorOperations<double>::subtract(angMomentumTotal, pointingLawParameters->desatMomentumRef,
-                                     deltaAngMomentum, 3);
+  VectorOperations<double>::subtract(angMomentumRw, pointingLawParameters->desatMomentumRef,
+                                     angMomentumTotal, 3);
 
   // resulting magnetic dipole command
   double crossAngMomentumMagField[3] = {0, 0, 0};
-  VectorOperations<double>::cross(deltaAngMomentum, magFieldBT, crossAngMomentumMagField);
+  VectorOperations<double>::cross(angMomentumTotal, magFieldBT, crossAngMomentumMagField);
   double factor =
       pointingLawParameters->deSatGainFactor / VectorOperations<double>::norm(magFieldBT, 3);
   VectorOperations<double>::mulScalar(crossAngMomentumMagField, factor, mgtDpDes, 3);
@@ -221,6 +219,8 @@ void PtgCtrl::rwAntistiction(ACS::SensorValues *sensorValues, int32_t *rwCmdSpee
             rwCmdSpeeds[i] = acsParameters->rwHandlingParameters.stictionSpeed;
           } else if (rwCmdSpeeds[i] < currRwSpeed[i]) {
             rwCmdSpeeds[i] = -acsParameters->rwHandlingParameters.stictionSpeed;
+          } else {
+            rwCmdSpeeds[i] = 0;
           }
         }
       }

mission/controller/acs/control/PtgCtrl.h

@@ -1,11 +1,16 @@
 #ifndef PTGCTRL_H_
 #define PTGCTRL_H_
 
-#include <math.h>
+#include <fsfw/globalfunctions/math/MatrixOperations.h>
+#include <fsfw/globalfunctions/math/QuaternionOperations.h>
+#include <fsfw/globalfunctions/math/VectorOperations.h>
+#include <fsfw/globalfunctions/sign.h>
 #include <mission/acs/defs.h>
 #include <mission/controller/acs/AcsParameters.h>
 #include <mission/controller/acs/SensorValues.h>
-#include <stdio.h>
+#include <mission/controller/controllerdefinitions/AcsCtrlDefinitions.h>
+
+#include <cmath>
 
 class PtgCtrl {
   /*
@@ -38,10 +43,11 @@ class PtgCtrl {
                     const int32_t speedRw0, const int32_t speedRw1, const int32_t speedRw2,
                     const int32_t speedRw3, double *rwTrqNs);
 
-  void ptgDesaturation(AcsParameters::PointingLawParameters *pointingLawParameters,
-                       const double *magFieldB, const bool magFieldBValid, const double *satRate,
-                       const int32_t speedRw0, const int32_t speedRw1, const int32_t speedRw2,
-                       const int32_t speedRw3, double *mgtDpDes);
+  void ptgDesaturation(const bool allRwAvabilable, const acsctrl::RwAvail *rwAvail,
+                       AcsParameters::PointingLawParameters *pointingLawParameters,
+                       const double *magFieldB, const bool magFieldBValid, const int32_t speedRw0,
+                       const int32_t speedRw1, const int32_t speedRw2, const int32_t speedRw3,
+                       double *mgtDpDes);
 
   /* @brief: Commands the stiction torque in case wheel speed is to low
    * 		 torqueCommand  modified torque after anti-stiction

mission/controller/acs/util/CholeskyDecomposition.h

@@ -1,98 +0,0 @@
-/*
- * TinyEKF: Extended Kalman Filter for embedded processors
- *
- * Copyright (C) 2015 Simon D. Levy
- *
- * MIT License
- */
-#ifndef CHOLESKYDECOMPOSITION_H_
-#define CHOLESKYDECOMPOSITION_H_
-#include <math.h>
-// typedef unsigned int uint8_t;
-
-template <typename T1, typename T2 = T1, typename T3 = T2>
-class CholeskyDecomposition {
- public:
-  static int invertCholesky(T1 *matrix, T2 *result, T3 *tempMatrix, const uint8_t dimension) {
-    // https://github.com/simondlevy/TinyEKF/blob/master/tiny_ekf.c
-    return cholsl(matrix, result, tempMatrix, dimension);
-  }
-
- private:
-  // https://github.com/simondlevy/TinyEKF/blob/master/tiny_ekf.c
-  static uint8_t choldc1(double *a, double *p, uint8_t n) {
-    int8_t i, j, k;
-    double sum;
-
-    for (i = 0; i < n; i++) {
-      for (j = i; j < n; j++) {
-        sum = a[i * n + j];
-        for (k = i - 1; k >= 0; k--) {
-          sum -= a[i * n + k] * a[j * n + k];
-        }
-        if (i == j) {
-          if (sum <= 0) {
-            return 1; /* error */
-          }
-          p[i] = sqrt(sum);
-        } else {
-          a[j * n + i] = sum / p[i];
-        }
-      }
-    }
-
-    return 0; /* success */
-  }
-
-  // https://github.com/simondlevy/TinyEKF/blob/master/tiny_ekf.c
-  static uint8_t choldcsl(double *A, double *a, double *p, uint8_t n) {
-    uint8_t i, j, k;
-    double sum;
-    for (i = 0; i < n; i++)
-      for (j = 0; j < n; j++) a[i * n + j] = A[i * n + j];
-    if (choldc1(a, p, n)) return 1;
-    for (i = 0; i < n; i++) {
-      a[i * n + i] = 1 / p[i];
-      for (j = i + 1; j < n; j++) {
-        sum = 0;
-        for (k = i; k < j; k++) {
-          sum -= a[j * n + k] * a[k * n + i];
-        }
-        a[j * n + i] = sum / p[j];
-      }
-    }
-
-    return 0; /* success */
-  }
-
-  // https://github.com/simondlevy/TinyEKF/blob/master/tiny_ekf.c
-  static uint8_t cholsl(double *A, double *a, double *p, uint8_t n) {
-    uint8_t i, j, k;
-    if (choldcsl(A, a, p, n)) return 1;
-    for (i = 0; i < n; i++) {
-      for (j = i + 1; j < n; j++) {
-        a[i * n + j] = 0.0;
-      }
-    }
-    for (i = 0; i < n; i++) {
-      a[i * n + i] *= a[i * n + i];
-      for (k = i + 1; k < n; k++) {
-        a[i * n + i] += a[k * n + i] * a[k * n + i];
-      }
-      for (j = i + 1; j < n; j++) {
-        for (k = j; k < n; k++) {
-          a[i * n + j] += a[k * n + i] * a[k * n + j];
-        }
-      }
-    }
-    for (i = 0; i < n; i++) {
-      for (j = 0; j < i; j++) {
-        a[i * n + j] = a[j * n + i];
-      }
-    }
-
-    return 0; /* success */
-  }
-};
-
-#endif /* CONTRIB_MATH_CHOLESKYDECOMPOSITION_H_ */

mission/controller/acs/util/MathOperations.h

@@ -1,465 +0,0 @@
-#ifndef MATH_MATHOPERATIONS_H_
-#define MATH_MATHOPERATIONS_H_
-
-#include <fsfw/src/fsfw/globalfunctions/constants.h>
-#include <fsfw/src/fsfw/globalfunctions/math/MatrixOperations.h>
-#include <fsfw/src/fsfw/globalfunctions/sign.h>
-#include <fsfw/src/fsfw/serviceinterface.h>
-
-#include <cmath>
-#include <cstring>
-#include <iostream>
-
-template <typename T1, typename T2 = T1>
-class MathOperations {
- public:
-  static void skewMatrix(const T1 vector[], T2 *result) {
-    // Input Dimension [3], Output [3][3]
-    result[0] = 0;
-    result[1] = -vector[2];
-    result[2] = vector[1];
-    result[3] = vector[2];
-    result[4] = 0;
-    result[5] = -vector[0];
-    result[6] = -vector[1];
-    result[7] = vector[0];
-    result[8] = 0;
-  }
-  static void vecTransposeVecMatrix(const T1 vector1[], const T1 transposeVector2[], T2 *result,
-                                    uint8_t size = 3) {
-    // Looks like MatrixOpertions::multiply is able to do the same thing
-    for (uint8_t resultColumn = 0; resultColumn < size; resultColumn++) {
-      for (uint8_t resultRow = 0; resultRow < size; resultRow++) {
-        result[resultColumn + size * resultRow] =
-            vector1[resultRow] * transposeVector2[resultColumn];
-      }
-    }
-    /*matrixSun[i][j] = sunEstB[i] * sunEstB[j];
-     matrixMag[i][j] = magEstB[i] * magEstB[j];
-     matrixSunMag[i][j] = sunEstB[i] * magEstB[j];
-     matrixMagSun[i][j] = magEstB[i] * sunEstB[j];*/
-  }
-
-  static void selectionSort(const T1 *matrix, T1 *result, uint8_t rowSize, uint8_t colSize) {
-    int min_idx;
-    T1 temp;
-    std::memcpy(result, matrix, rowSize * colSize * sizeof(*result));
-    // One by one move boundary of unsorted subarray
-    for (int k = 0; k < rowSize; k++) {
-      for (int i = 0; i < colSize - 1; i++) {
-        // Find the minimum element in unsorted array
-        min_idx = i;
-        for (int j = i + 1; j < colSize; j++) {
-          if (result[j + k * colSize] < result[min_idx + k * colSize]) {
-            min_idx = j;
-          }
-        }
-        // Swap the found minimum element with the first element
-        temp = result[i + k * colSize];
-        result[i + k * colSize] = result[min_idx + k * colSize];
-        result[min_idx + k * colSize] = temp;
-      }
-    }
-  }
-
-  static void convertDateToJD2000(const T1 time, T2 julianDate) {
-    // time = { Y, M, D, h, m,s}
-    // time in sec and microsec -> The Epoch (unixtime)
-    julianDate = 1721013.5 + 367 * time[0] - floor(7 / 4 * (time[0] + (time[1] + 9) / 12)) +
-                 floor(275 * time[1] / 9) + time[2] +
-                 (60 * time[3] + time[4] + (time(5) / 60)) / 1440;
-  }
-
-  static T1 convertUnixToJD2000(timeval time) {
-    // time = {{s},{us}}
-    T1 julianDate2000;
-    julianDate2000 = (time.tv_sec / 86400.0) + 2440587.5 - 2451545;
-    return julianDate2000;
-  }
-
-  static void dcmFromQuat(const T1 vector[], T1 *outputDcm) {
-    // convention q = [qx,qy,qz, qw]
-    outputDcm[0] = pow(vector[0], 2) - pow(vector[1], 2) - pow(vector[2], 2) + pow(vector[3], 2);
-    outputDcm[1] = 2 * (vector[0] * vector[1] + vector[2] * vector[3]);
-    outputDcm[2] = 2 * (vector[0] * vector[2] - vector[1] * vector[3]);
-
-    outputDcm[3] = 2 * (vector[1] * vector[0] - vector[2] * vector[3]);
-    outputDcm[4] = -pow(vector[0], 2) + pow(vector[1], 2) - pow(vector[2], 2) + pow(vector[3], 2);
-    outputDcm[5] = 2 * (vector[1] * vector[2] + vector[0] * vector[3]);
-
-    outputDcm[6] = 2 * (vector[2] * vector[0] + vector[1] * vector[3]);
-    outputDcm[7] = 2 * (vector[2] * vector[1] - vector[0] * vector[3]);
-    outputDcm[8] = -pow(vector[0], 2) - pow(vector[1], 2) + pow(vector[2], 2) + pow(vector[3], 2);
-  }
-
-  static void cartesianFromLatLongAlt(const T1 lat, const T1 longi, const T1 alt,
-                                      T2 *cartesianOutput) {
-    /* @brief:  cartesianFromLatLongAlt() - calculates cartesian coordinates in ECEF from latitude,
-     * 								longitude and altitude
-     * @param:  lat   				geodetic latitude [rad]
-     * 			longi 				longitude [rad]
-     * 			alt					altitude [m]
-     * 			cartesianOutput 	Cartesian Coordinates in ECEF (3x1)
-     * @source: Fundamentals of Spacecraft Attitude Determination and Control, P.34ff
-     * 			Landis Markley and John L. Crassidis*/
-    double radiusPolar = 6356752.314;
-    double radiusEqua = 6378137;
-
-    double eccentricity = sqrt(1 - pow(radiusPolar, 2) / pow(radiusEqua, 2));
-    double auxRadius = radiusEqua / sqrt(1 - pow(eccentricity, 2) * pow(sin(lat), 2));
-
-    cartesianOutput[0] = (auxRadius + alt) * cos(lat) * cos(longi);
-    cartesianOutput[1] = (auxRadius + alt) * cos(lat) * sin(longi);
-    cartesianOutput[2] = ((1 - pow(eccentricity, 2)) * auxRadius + alt) * sin(lat);
-  }
-
-  static void latLongAltFromCartesian(const T1 *vector, T1 &latitude, T1 &longitude, T1 &altitude) {
-    /* @brief:  latLongAltFromCartesian() - calculates latitude, longitude and altitude from
-     * cartesian coordinates in ECEF
-     * @param:  x   			x-value of position vector [m]
-     * 			y 				y-value of position vector [m]
-     * 			z				z-value of position vector [m]
-     * 			latitude 		geodetic latitude [rad]
-     * 			longitude		longitude [rad]
-     * 			altitude		altitude [m]
-     * @source: Fundamentals of Spacecraft Attitude Determination and Control, P.35 f
-     * 			Landis Markley and John L. Crassidis*/
-    // From World Geodetic System the Earth Radii
-    double a = 6378137.0;     // semimajor axis [m]
-    double b = 6356752.3142;  // semiminor axis [m]
-
-    // Calculation
-    double e2 = 1 - pow(b, 2) / pow(a, 2);
-    double epsilon2 = pow(a, 2) / pow(b, 2) - 1;
-    double rho = sqrt(pow(vector[0], 2) + pow(vector[1], 2));
-    double p = std::abs(vector[2]) / epsilon2;
-    double s = pow(rho, 2) / (e2 * epsilon2);
-    double q = pow(p, 2) - pow(b, 2) + s;
-    double u = p / sqrt(q);
-    double v = pow(b, 2) * pow(u, 2) / q;
-    double P = 27 * v * s / q;
-    double Q = pow(sqrt(P + 1) + sqrt(P), 2. / 3.);
-    double t = (1 + Q + 1 / Q) / 6;
-    double c = sqrt(pow(u, 2) - 1 + 2 * t);
-    double w = (c - u) / 2;
-    double d =
-        sign(vector[2]) * sqrt(q) * (w + sqrt(sqrt(pow(t, 2) + v) - u * w - t / 2 - 1. / 4.));
-    double N = a * sqrt(1 + epsilon2 * pow(d, 2) / pow(b, 2));
-    latitude = asin((epsilon2 + 1) * d / N);
-    altitude = rho * cos(latitude) + vector[2] * sin(latitude) - pow(a, 2) / N;
-    longitude = atan2(vector[1], vector[0]);
-  }
-
-  static void dcmEJ(timeval time, T1 *outputDcmEJ, T1 *outputDotDcmEJ) {
-    /* @brief:  dcmEJ() - calculates the transformation matrix between ECEF and ECI frame
-     * @param:  time   			Current time
-     * 			outputDcmEJ 	Transformation matrix from ECI (J) to ECEF (E) [3][3]
-     * 			outputDotDcmEJ	Derivative of transformation matrix [3][3]
-     * @source: Fundamentals of Spacecraft Attitude Determination and Control, P.32ff
-     * 			Landis Markley and John L. Crassidis*/
-    double JD2000Floor = 0;
-    double JD2000 = convertUnixToJD2000(time);
-    // Getting Julian Century from Day start : JD (Y,M,D,0,0,0)
-    JD2000Floor = floor(JD2000);
-    if ((JD2000 - JD2000Floor) < 0.5) {
-      JD2000Floor -= 0.5;
-    } else {
-      JD2000Floor += 0.5;
-    }
-
-    double JC2000 = JD2000Floor / 36525;
-    double sec = (JD2000 - JD2000Floor) * 86400;
-    double gmst = 0;  // greenwich mean sidereal time
-    gmst = 24110.54841 + 8640184.812866 * JC2000 + 0.093104 * pow(JC2000, 2) -
-           0.0000062 * pow(JC2000, 3) + 1.002737909350795 * sec;
-    double rest = gmst / 86400;
-    double FloorRest = floor(rest);
-    double secOfDay = rest - FloorRest;
-    secOfDay *= 86400;
-    gmst = secOfDay / 240 * M_PI / 180;
-
-    outputDcmEJ[0] = cos(gmst);
-    outputDcmEJ[1] = sin(gmst);
-    outputDcmEJ[2] = 0;
-    outputDcmEJ[3] = -sin(gmst);
-    outputDcmEJ[4] = cos(gmst);
-    outputDcmEJ[5] = 0;
-    outputDcmEJ[6] = 0;
-    outputDcmEJ[7] = 0;
-    outputDcmEJ[8] = 1;
-
-    //	Derivative of dmcEJ WITHOUT PRECISSION AND NUTATION
-    double dcmEJCalc[3][3] = {{outputDcmEJ[0], outputDcmEJ[1], outputDcmEJ[2]},
-                              {outputDcmEJ[3], outputDcmEJ[4], outputDcmEJ[5]},
-                              {outputDcmEJ[6], outputDcmEJ[7], outputDcmEJ[8]}};
-    double dcmDot[3][3] = {{0, 1, 0}, {-1, 0, 0}, {0, 0, 0}};
-    double omegaEarth = 0.000072921158553;
-    double dotDcmEJ[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-    MatrixOperations<double>::multiply(*dcmDot, *dcmEJCalc, *dotDcmEJ, 3, 3, 3);
-    MatrixOperations<double>::multiplyScalar(*dotDcmEJ, omegaEarth, outputDotDcmEJ, 3, 3);
-  }
-
-  /* @brief:  ecfToEciWithNutPre() - calculates the transformation matrix between ECEF and ECI frame
-   * 			give also the back the derivative of this matrix
-   * @param:  unixTime   		Current time in Unix format
-   * 			outputDcmEJ 	Transformation matrix from ECI (J) to ECEF (E) [3][3]
-   * 			outputDotDcmEJ	Derivative of transformation matrix [3][3]
-   * @source: Entwicklung einer Simulationsumgebung und robuster Algorithmen für das Lage- und
-                          Orbitkontrollsystem der Kleinsatelliten Flying Laptop und PERSEUS, P.244ff
-   * 			Oliver Zeile
-   *
-   https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_Studenten/Marquardt_Robin&openfile=896110*/
-  static void ecfToEciWithNutPre(timeval unixTime, T1 *outputDcmEJ, T1 *outputDotDcmEJ) {
-    //		TT = UTC/Unix + 32.184s (TAI Difference) + 27 (Leap Seconds in UTC since 1972) + 10
-    //(initial Offset) 		International Atomic Time (TAI)
-
-    double JD2000UTC1 = convertUnixToJD2000(unixTime);
-
-    //		Julian Date / century from TT
-    timeval terestrialTime = unixTime;
-    terestrialTime.tv_sec = unixTime.tv_sec + 32.184 + 37;
-    double JD2000TT = convertUnixToJD2000(terestrialTime);
-    double JC2000TT = JD2000TT / 36525;
-
-    //-------------------------------------------------------------------------------------
-    //		Calculation of Transformation from earth rotation Theta
-    //-------------------------------------------------------------------------------------
-    double theta[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-    //		Earth Rotation angle
-    double era = 0;
-    era = 2 * M_PI * (0.779057273264 + 1.00273781191135448 * JD2000UTC1);
-    //		Greenwich Mean Sidereal Time
-    double gmst2000 = 0.014506 + 4612.15739966 * JC2000TT + 1.39667721 * pow(JC2000TT, 2) -
-                      0.00009344 * pow(JC2000TT, 3) + 0.00001882 * pow(JC2000TT, 4);
-    double arcsecFactor = 1 * M_PI / (180 * 3600);
-    gmst2000 *= arcsecFactor;
-    gmst2000 += era;
-
-    theta[0][0] = cos(gmst2000);
-    theta[0][1] = sin(gmst2000);
-    theta[0][2] = 0;
-    theta[1][0] = -sin(gmst2000);
-    theta[1][1] = cos(gmst2000);
-    theta[1][2] = 0;
-    theta[2][0] = 0;
-    theta[2][1] = 0;
-    theta[2][2] = 1;
-
-    //-------------------------------------------------------------------------------------
-    //		Calculation of Transformation from earth Precession P
-    //-------------------------------------------------------------------------------------
-    double precession[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-
-    double zeta = 2306.2181 * JC2000TT + 0.30188 * pow(JC2000TT, 2) + 0.017998 * pow(JC2000TT, 3);
-    double theta2 = 2004.3109 * JC2000TT - 0.42665 * pow(JC2000TT, 2) - 0.041833 * pow(JC2000TT, 3);
-    double ze = zeta + 0.79280 * pow(JC2000TT, 2) + 0.000205 * pow(JC2000TT, 3);
-
-    zeta *= arcsecFactor;
-    theta2 *= arcsecFactor;
-    ze *= arcsecFactor;
-
-    precession[0][0] = -sin(ze) * sin(zeta) + cos(ze) * cos(theta2) * cos(zeta);
-    precession[1][0] = cos(ze) * sin(zeta) + sin(ze) * cos(theta2) * cos(zeta);
-    precession[2][0] = sin(theta2) * cos(zeta);
-    precession[0][1] = -sin(ze) * cos(zeta) - cos(ze) * cos(theta2) * sin(zeta);
-    precession[1][1] = cos(ze) * cos(zeta) - sin(ze) * cos(theta2) * sin(zeta);
-    precession[2][1] = -sin(theta2) * sin(zeta);
-    precession[0][2] = -cos(ze) * sin(theta2);
-    precession[1][2] = -sin(ze) * sin(theta2);
-    precession[2][2] = cos(theta2);
-
-    //-------------------------------------------------------------------------------------
-    //		Calculation of Transformation from earth Nutation N
-    //-------------------------------------------------------------------------------------
-    double nutation[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-    //      lunar asc node
-    double Om = 125 * 3600 + 2 * 60 + 40.28 - (1934 * 3600 + 8 * 60 + 10.539) * JC2000TT +
-                7.455 * pow(JC2000TT, 2) + 0.008 * pow(JC2000TT, 3);
-    Om *= arcsecFactor;
-    //      delta psi approx
-    double dp = -17.2 * arcsecFactor * sin(Om);
-
-    //      delta eps approx
-    double de = 9.203 * arcsecFactor * cos(Om);
-
-    //        % true obliquity of the ecliptic eps p.71 (simplified)
-    double e = 23.43929111 * M_PI / 180 - 46.8150 / 3600 * JC2000TT * M_PI / 180;
-
-    nutation[0][0] = cos(dp);
-    nutation[1][0] = cos(e + de) * sin(dp);
-    nutation[2][0] = sin(e + de) * sin(dp);
-    nutation[0][1] = -cos(e) * sin(dp);
-    nutation[1][1] = cos(e) * cos(e + de) * cos(dp) + sin(e) * sin(e + de);
-    nutation[2][1] = cos(e) * sin(e + de) * cos(dp) - sin(e) * cos(e + de);
-    nutation[0][2] = -sin(e) * sin(dp);
-    nutation[1][2] = sin(e) * cos(e + de) * cos(dp) - cos(e) * sin(e + de);
-    nutation[2][2] = sin(e) * sin(e + de) * cos(dp) + cos(e) * cos(e + de);
-
-    //-------------------------------------------------------------------------------------
-    //		Calculation of Derivative of rotation matrix from earth
-    //-------------------------------------------------------------------------------------
-    double thetaDot[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-    double dotMatrix[3][3] = {{0, 1, 0}, {-1, 0, 0}, {0, 0, 0}};
-    double omegaEarth = 0.000072921158553;
-    MatrixOperations<double>::multiply(*dotMatrix, *theta, *thetaDot, 3, 3, 3);
-    MatrixOperations<double>::multiplyScalar(*thetaDot, omegaEarth, *thetaDot, 3, 3);
-
-    //-------------------------------------------------------------------------------------
-    //		Calculation of transformation matrix and Derivative of transformation matrix
-    //-------------------------------------------------------------------------------------
-    double nutationPrecession[3][3] = {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}};
-    MatrixOperations<double>::multiply(*nutation, *precession, *nutationPrecession, 3, 3, 3);
-    MatrixOperations<double>::multiply(*nutationPrecession, *theta, outputDcmEJ, 3, 3, 3);
-
-    MatrixOperations<double>::multiply(*nutationPrecession, *thetaDot, outputDotDcmEJ, 3, 3, 3);
-  }
-  static void inverseMatrixDimThree(const T1 *matrix, T1 *output) {
-    int i, j;
-    double determinant = 0;
-    double mat[3][3] = {{matrix[0], matrix[1], matrix[2]},
-                        {matrix[3], matrix[4], matrix[5]},
-                        {matrix[6], matrix[7], matrix[8]}};
-
-    for (i = 0; i < 3; i++) {
-      determinant = determinant + (mat[0][i] * (mat[1][(i + 1) % 3] * mat[2][(i + 2) % 3] -
-                                                mat[1][(i + 2) % 3] * mat[2][(i + 1) % 3]));
-    }
-    //		cout<<"\n\ndeterminant: "<<determinant;
-    //		cout<<"\n\nInverse of matrix is: \n";
-    for (i = 0; i < 3; i++) {
-      for (j = 0; j < 3; j++) {
-        output[i * 3 + j] = ((mat[(j + 1) % 3][(i + 1) % 3] * mat[(j + 2) % 3][(i + 2) % 3]) -
-                             (mat[(j + 1) % 3][(i + 2) % 3] * mat[(j + 2) % 3][(i + 1) % 3])) /
-                            determinant;
-      }
-    }
-  }
-
-  static float matrixDeterminant(const T1 *inputMatrix, uint8_t size) {
-    /* do not use this. takes 300ms */
-    float det = 0;
-    T1 matrix[size][size], submatrix[size - 1][size - 1];
-    for (uint8_t row = 0; row < size; row++) {
-      for (uint8_t col = 0; col < size; col++) {
-        matrix[row][col] = inputMatrix[row * size + col];
-      }
-    }
-    if (size == 2)
-      return ((matrix[0][0] * matrix[1][1]) - (matrix[1][0] * matrix[0][1]));
-    else {
-      for (uint8_t col = 0; col < size; col++) {
-        int subRow = 0;
-        for (uint8_t rowIndex = 1; rowIndex < size; rowIndex++) {
-          int subCol = 0;
-          for (uint8_t colIndex = 0; colIndex < size; colIndex++) {
-            if (colIndex == col) continue;
-            submatrix[subRow][subCol] = matrix[rowIndex][colIndex];
-            subCol++;
-          }
-          subRow++;
-        }
-        det += (pow(-1, col) * matrix[0][col] *
-                MathOperations<T1>::matrixDeterminant(*submatrix, size - 1));
-      }
-    }
-    return det;
-  }
-
-  static int inverseMatrix(const T1 *inputMatrix, T1 *inverse, uint8_t size) {
-    // Stopwatch stopwatch;
-    T1 matrix[size][size], identity[size][size];
-    // reformat array to matrix
-    for (uint8_t row = 0; row < size; row++) {
-      for (uint8_t col = 0; col < size; col++) {
-        matrix[row][col] = inputMatrix[row * size + col];
-      }
-    }
-    // init identity matrix
-    std::memset(identity, 0.0, sizeof(identity));
-    for (uint8_t diag = 0; diag < size; diag++) {
-      identity[diag][diag] = 1;
-    }
-    // gauss-jordan algo
-    // sort matrix such as no diag entry shall be 0
-    for (uint8_t row = 0; row < size; row++) {
-      if (matrix[row][row] == 0.0) {
-        bool swaped = false;
-        uint8_t rowIndex = 0;
-        while ((rowIndex < size) && !swaped) {
-          if ((matrix[rowIndex][row] != 0.0) && (matrix[row][rowIndex] != 0.0)) {
-            for (uint8_t colIndex = 0; colIndex < size; colIndex++) {
-              std::swap(matrix[row][colIndex], matrix[rowIndex][colIndex]);
-              std::swap(identity[row][colIndex], identity[rowIndex][colIndex]);
-            }
-            swaped = true;
-          }
-          rowIndex++;
-        }
-        if (!swaped) {
-          return 1;  // matrix not invertible
-        }
-      }
-    }
-
-    for (int row = 0; row < size; row++) {
-      if (matrix[row][row] == 0.0) {
-        uint8_t rowIndex;
-        if (row == 0) {
-          rowIndex = size - 1;
-        } else {
-          rowIndex = row - 1;
-        }
-        for (uint8_t colIndex = 0; colIndex < size; colIndex++) {
-          std::swap(matrix[row][colIndex], matrix[rowIndex][colIndex]);
-          std::swap(identity[row][colIndex], identity[rowIndex][colIndex]);
-        }
-        row--;
-        if (row < 0) {
-          return 1;  // Matrix is not invertible
-        }
-      }
-    }
-    // remove non diag elements in matrix (jordan)
-    for (int row = 0; row < size; row++) {
-      for (int rowIndex = 0; rowIndex < size; rowIndex++) {
-        if (row != rowIndex) {
-          double ratio = matrix[rowIndex][row] / matrix[row][row];
-          for (int colIndex = 0; colIndex < size; colIndex++) {
-            matrix[rowIndex][colIndex] -= ratio * matrix[row][colIndex];
-            identity[rowIndex][colIndex] -= ratio * identity[row][colIndex];
-          }
-        }
-      }
-    }
-    // normalize rows in matrix (gauss)
-    for (int row = 0; row < size; row++) {
-      for (int col = 0; col < size; col++) {
-        identity[row][col] = identity[row][col] / matrix[row][row];
-      }
-    }
-    std::memcpy(inverse, identity, sizeof(identity));
-    return 0;  // successful inversion
-  }
-
-  static bool checkVectorIsFinite(const T1 *inputVector, uint8_t size) {
-    for (uint8_t i = 0; i < size; i++) {
-      if (not isfinite(inputVector[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  static bool checkMatrixIsFinite(const T1 *inputMatrix, uint8_t rows, uint8_t cols) {
-    for (uint8_t col = 0; col < cols; col++) {
-      for (uint8_t row = 0; row < rows; row++) {
-        if (not isfinite(inputMatrix[row * cols + cols])) {
-          return false;
-        }
-      }
-    }
-    return true;
-  }
-};
-
-#endif /* ACS_MATH_MATHOPERATIONS_H_ */

mission/controller/controllerdefinitions/AcsCtrlDefinitions.h

@@ -21,6 +21,13 @@ static constexpr ReturnValue_t SINGLE_RW_UNAVAILABLE = MAKE_RETURN_CODE(0xA3);
 //! [EXPORT] : [COMMENT] Multiple RWs have failed.
 static constexpr ReturnValue_t MULTIPLE_RW_UNAVAILABLE = MAKE_RETURN_CODE(0xA4);
 
+struct RwAvail {
+  bool rw1avail = false;
+  bool rw2avail = false;
+  bool rw3avail = false;
+  bool rw4avail = false;
+};
+
 enum SetIds : uint32_t {
   MGM_SENSOR_DATA,
   MGM_PROCESSED_DATA,

mission/genericFactory.cpp

@@ -250,20 +250,30 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
                            pus::PUS_SERVICE_2, 3, 10);
   new Service3Housekeeping(objects::PUS_SERVICE_3_HOUSEKEEPING, config::EIVE_PUS_APID,
                            pus::PUS_SERVICE_3, config::HK_SERVICE_QUEUE_DEPTH, 16);
-  new Service5EventReporting(
-      PsbParams(objects::PUS_SERVICE_5_EVENT_REPORTING, config::EIVE_PUS_APID, pus::PUS_SERVICE_5),
-      80, 160);
+
+  auto psbParamsService5 =
+      PsbParams(objects::PUS_SERVICE_5_EVENT_REPORTING, config::EIVE_PUS_APID, pus::PUS_SERVICE_5);
+  psbParamsService5.requestQueueDepth = 50;
+  psbParamsService5.maxPacketsPerCycle = 50;
+  new Service5EventReporting(psbParamsService5, 80, 160);
   new Service8FunctionManagement(objects::PUS_SERVICE_8_FUNCTION_MGMT, config::EIVE_PUS_APID,
                                  pus::PUS_SERVICE_8, config::ACTION_SERVICE_QUEUE_DEPTH, 16, 60);
   new Service9TimeManagement(
       PsbParams(objects::PUS_SERVICE_9_TIME_MGMT, config::EIVE_PUS_APID, pus::PUS_SERVICE_9));
 
-  new Service11TelecommandScheduling<common::OBSW_MAX_SCHEDULED_TCS>(
-      PsbParams(objects::PUS_SERVICE_11_TC_SCHEDULER, config::EIVE_PUS_APID, pus::PUS_SERVICE_11),
+  auto psbParamsService11 =
+      PsbParams(objects::PUS_SERVICE_11_TC_SCHEDULER, config::EIVE_PUS_APID, pus::PUS_SERVICE_11);
+  psbParamsService11.requestQueueDepth = 100;
+  psbParamsService11.maxPacketsPerCycle = 100;
+  new Service11TelecommandScheduling<common::OBSW_MAX_SCHEDULED_TCS>(psbParamsService11,
                                                                      ccsdsDistrib);
+
   new Service15TmStorage(objects::PUS_SERVICE_15_TM_STORAGE, config::EIVE_PUS_APID, 10);
-  new Service17Test(
-      PsbParams(objects::PUS_SERVICE_17_TEST, config::EIVE_PUS_APID, pus::PUS_SERVICE_17));
+  auto psbParamsService17 =
+      PsbParams(objects::PUS_SERVICE_17_TEST, config::EIVE_PUS_APID, pus::PUS_SERVICE_17);
+  psbParamsService17.requestQueueDepth = 50;
+  psbParamsService17.maxPacketsPerCycle = 50;
+  new Service17Test(psbParamsService17);
   new Service20ParameterManagement(objects::PUS_SERVICE_20_PARAMETERS, config::EIVE_PUS_APID,
                                    pus::PUS_SERVICE_20);
   new CService200ModeCommanding(objects::PUS_SERVICE_200_MODE_MGMT, config::EIVE_PUS_APID,

mission/pollingSeqTables.cpp

@@ -10,6 +10,7 @@
 #include "OBSWConfig.h"
 #include "eive/definitions.h"
 #include "eive/objects.h"
+#include "linux/payload/FreshMpsocHandler.h"
 #include "linux/payload/FreshSupvHandler.h"
 
 #ifndef RPI_TEST_ADIS16507
@@ -617,17 +618,21 @@ ReturnValue_t pst::pstPayload(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0,
                         DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 
   thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0,
                         FreshSupvHandler::OpCode::DEFAULT_OPERATION);
-  // Two COM TM steps, which might cover telemetry which takes a bit longer to be sent.
+  // Parse TM with a bit of delay. Two COM steps which might cover telemetry wehich takes a bit
+  // longer to send
   thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.1,
                         FreshSupvHandler::OpCode::PARSE_TM);
   thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.2,
                         FreshSupvHandler::OpCode::PARSE_TM);
+  // Parse TM with a bit of delay. Two COM steps which might cover telemetry wehich takes a bit
+  // longer to send
+  thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.2,
+                        FreshMpsocHandler::OpCode::PARSE_TM);
+  thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.4,
+                        FreshMpsocHandler::OpCode::PARSE_TM);
 
   thisSequence->addSlot(objects::SCEX, length * 0.6, DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::SCEX, length * 0.6, DeviceHandlerIF::SEND_WRITE);

mission/sysDefs.h

@@ -55,6 +55,7 @@ static constexpr char VERSION_FILE_NAME[] = "version.txt";
 static constexpr char LEGACY_REBOOT_WATCHDOG_FILE_NAME[] = "reboot.txt";
 static constexpr char REBOOT_WATCHDOG_FILE_NAME[] = "reboot_watchdog.txt";
 static constexpr char REBOOT_COUNTER_FILE_NAME[] = "reboot_counters.txt";
+static constexpr char LEAP_SECONDS_FILE_NAME[] = "leapseconds.txt";
 static constexpr char TIME_FILE_NAME[] = "time_backup.txt";
 
 static constexpr uint32_t SYS_ROM_BASE_ADDR = 0x80000000;
@@ -93,6 +94,8 @@ static constexpr ActionId_t MV_HELPER = 53;
 static constexpr ActionId_t RM_HELPER = 54;
 static constexpr ActionId_t MKDIR_HELPER = 55;
 
+static constexpr ActionId_t UPDATE_LEAP_SECONDS = 60;
+
 static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CORE;
 
 static constexpr Event ALLOC_FAILURE = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);

mission/system/CMakeLists.txt

@@ -3,8 +3,9 @@ add_subdirectory(acs)
 add_subdirectory(tcs)
 add_subdirectory(com)
 add_subdirectory(power)
+add_subdirectory(payload)
 
 target_sources(
   ${LIB_EIVE_MISSION}
   PRIVATE systemTree.cpp DualLanePowerStateMachine.cpp EiveSystem.cpp
-          treeUtil.cpp SharedPowerAssemblyBase.cpp payloadModeTree.cpp)
+          treeUtil.cpp SharedPowerAssemblyBase.cpp)

mission/system/acs/StrFdir.cpp

@@ -1,6 +1,8 @@
 #include "StrFdir.h"
 
-#include "mission/acs/defs.h"
+#include <eive/objects.h>
+#include <fsfw/events/EventManagerIF.h>
+#include <mission/acs/defs.h>
 
 StrFdir::StrFdir(object_id_t strObject)
     : DeviceHandlerFailureIsolation(strObject, objects::NO_OBJECT) {}
@@ -12,3 +14,13 @@ ReturnValue_t StrFdir::eventReceived(EventMessage* event) {
   }
   return DeviceHandlerFailureIsolation::eventReceived(event);
 }
+
+ReturnValue_t StrFdir::initialize() {
+  ReturnValue_t result = DeviceHandlerFailureIsolation::initialize();
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
+  return manager->subscribeToEvent(eventQueue->getId(),
+                                   event::getEventId(acs::PTG_CTRL_NO_ATTITUDE_INFORMATION));
+}

mission/system/acs/StrFdir.h

@@ -6,6 +6,7 @@
 class StrFdir : public DeviceHandlerFailureIsolation {
  public:
   StrFdir(object_id_t strObject);
+  ReturnValue_t initialize() override;
   ReturnValue_t eventReceived(EventMessage* event) override;
 };
 

mission/system/payload/CMakeLists.txt

@@ -0,0 +1 @@
+target_sources(${LIB_EIVE_MISSION} PRIVATE payloadModeTree.cpp)

mission/system/systemTree.cpp

@@ -10,7 +10,7 @@
 #include "mission/com/defs.h"
 #include "mission/sysDefs.h"
 #include "mission/system/acs/acsModeTree.h"
-#include "mission/system/payloadModeTree.h"
+#include "mission/system/payload/payloadModeTree.h"
 #include "mission/system/power/epsModeTree.h"
 #include "mission/system/tcs/tcsModeTree.h"
 #include "treeUtil.h"

q7s-env.sh

@@ -9,7 +9,7 @@ export ZYNQ_7020_SYSROOT="/opt/xiphos/sdk/ark/sysroots/cortexa9hf-neon-xiphos-li
 
 export PATH=${CROSS_COMPILE_BIN_PATH}:$PATH
 export CROSS_COMPILE="arm-linux-gnueabihf"
-# export EIVE_Q7S_EM=1
+unset EIVE_Q7S_EM
 
 if [[ -d "eive-obsw" ]]; then
 	echo "Detected EIVE OBSW root directory at $(pwd)/eive-obsw. Setting to EIVE_OBSW_ROOT"

scripts/q7s-cp.py

@@ -4,6 +4,9 @@ import os
 import sys
 
 
+DEFAULT_PORT = 1539
+
+
 def main():
     args = handle_args()
     cmd = build_cmd(args)
@@ -20,7 +23,7 @@ def prompt_ssh_key_removal():
     do_remove_key = input(
         "Do you want to remove problematic keys on localhost ([Y]/n)?: "
     )
-    if not do_remove_key.lower() in ["y", "yes", "1", ""]:
+    if do_remove_key.lower() not in ["y", "yes", "1", ""]:
         sys.exit(1)
     port = 0
     while True:
@@ -54,7 +57,7 @@ def handle_args():
         "If files are copied back to host, will be current directory by default",
         default="",
     )
-    parser.add_argument("-P", "--port", help="Target port", default=1535)
+    parser.add_argument("-P", "--port", help="Target port", default=DEFAULT_PORT)
     parser.add_argument(
         "-i",
         "--invert",

thirdparty/sagittactl

@@ -1 +1 @@
-Subproject commit 20f32a2f291d00869c693066de02c0257dec7be4
+Subproject commit a558693675dae09aff7ef74242c25f826584c46a

tmtc

@@ -1 +1 @@
-Subproject commit d33013ed58131a69d09145af4f3c7a71766cebd3
+Subproject commit 9a06c64dfac3f4283c2d5af72a9c095f4726480b

unittest/CMakeLists.txt

@@ -6,5 +6,6 @@ target_sources(${UNITTEST_NAME} PRIVATE
     testEnvironment.cpp
     testGenericFilesystem.cpp
     hdlcEncodingRw.cpp
+    mpsocTests.cpp
     printChar.cpp
 )

unittest/mpsocTests.cpp

@@ -0,0 +1,14 @@
+
+#include <catch2/catch_test_macros.hpp>
+
+TEST_CASE("MPSoC helper tests", "[payload]") {
+  char divStr[16]{};
+  uint32_t divParam = 0;
+
+  SECTION("Simple Test") {
+    divParam = 3;
+    CHECK(divParam < 999);
+    sprintf(divStr, "DIV%03u", divParam);
+    REQUIRE(strcmp(divStr, "DIV003") == 0);
+  }
+}