bsp_egse/main.cpp

@@ -3,8 +3,8 @@
 #include "InitMission.h"
 #include "OBSWConfig.h"
 #include "OBSWVersion.h"
-#include "fsfw/version.h"
 #include "fsfw/tasks/TaskFactory.h"
+#include "fsfw/version.h"
 
 /**
  * @brief 	    This is the main program entry point for the egse (raspberry pi 4)

bsp_q7s/core/ObjectFactory.cpp

@@ -19,12 +19,6 @@
 #include "bsp_q7s/callbacks/pcduSwitchCb.h"
 #include "bsp_q7s/callbacks/rwSpiCallback.h"
 #include "bsp_q7s/core/CoreController.h"
-#include "linux/devices/ploc/PlocMemoryDumper.h"
-#include "linux/devices/ploc/PlocSupervisorHandler.h"
-#include "linux/devices/ploc/PlocUpdater.h"
-#include "linux/devices/ploc/PlocMPSoCHandler.h"
-#include "linux/devices/ploc/PlocMPSoCHelper.h"
-#include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #include "bsp_q7s/memory/FileSystemHandler.h"
 #include "busConf.h"
 #include "ccsdsConfig.h"
@@ -38,7 +32,13 @@
 #include "linux/csp/CspComIF.h"
 #include "linux/csp/CspCookie.h"
 #include "linux/devices/GPSHyperionLinuxController.h"
+#include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
+#include "linux/devices/ploc/PlocMPSoCHandler.h"
+#include "linux/devices/ploc/PlocMPSoCHelper.h"
+#include "linux/devices/ploc/PlocMemoryDumper.h"
+#include "linux/devices/ploc/PlocSupervisorHandler.h"
+#include "linux/devices/ploc/PlocUpdater.h"
 #include "linux/devices/startracker/StarTrackerHandler.h"
 #include "linux/devices/startracker/StrHelper.h"
 #include "tmtc/apid.h"
@@ -181,12 +181,12 @@ void ObjectFactory::produce(void* args) {
 #endif
 
 #if OBSW_ADD_PLOC_MPSOC == 1
-	UartCookie* plocMpsocCookie = new UartCookie(objects::PLOC_MPSOC_HANDLER,
+  UartCookie* plocMpsocCookie =
-			q7s::UART_PLOC_MPSOC_DEV, UartModes::NON_CANONICAL, uart::PLOC_MPSOC_BAUD,
+      new UartCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV,
-			mpsoc::MAX_REPLY_SIZE);
+                     UartModes::NON_CANONICAL, uart::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE);
   PlocMPSoCHelper* plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
-	PlocMPSoCHandler* plocMPSoCHandler = new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER,
+  PlocMPSoCHandler* plocMPSoCHandler = new PlocMPSoCHandler(
-			objects::UART_COM_IF, plocMpsocCookie, plocMpsocHelper);
+      objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, plocMpsocCookie, plocMpsocHelper);
   plocMPSoCHandler->setStartUpImmediately();
 #endif /* OBSW_ADD_PLOC_MPSOC == 1 */
 

bsp_q7s/memory/FilesystemHelper.cpp

@@ -1,14 +1,14 @@
-#include <fstream>
-#include <filesystem>
 #include "FilesystemHelper.h"
+
+#include <filesystem>
+#include <fstream>
+
 #include "bsp_q7s/memory/SdCardManager.h"
 #include "fsfw/serviceinterface/ServiceInterfaceStream.h"
 
-FilesystemHelper::FilesystemHelper() {
+FilesystemHelper::FilesystemHelper() {}
-}
 
-FilesystemHelper::~FilesystemHelper() {
+FilesystemHelper::~FilesystemHelper() {}
-}
 
 ReturnValue_t FilesystemHelper::checkPath(std::string path) {
   SdCardManager* sdcMan = SdCardManager::instance();
@@ -16,14 +16,14 @@ ReturnValue_t FilesystemHelper::checkPath(std::string path) {
     sif::warning << "FilesystemHelper::checkPath: Invalid SD card manager" << std::endl;
     return RETURN_FAILED;
   }
-    if (path.substr(0, sizeof(SdCardManager::SD_0_MOUNT_POINT))
+  if (path.substr(0, sizeof(SdCardManager::SD_0_MOUNT_POINT)) ==
-            == std::string(SdCardManager::SD_0_MOUNT_POINT)) {
+      std::string(SdCardManager::SD_0_MOUNT_POINT)) {
     if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
       sif::warning << "FilesystemHelper::checkPath: SD card 0 not mounted" << std::endl;
       return SD_NOT_MOUNTED;
     }
-    } else if (path.substr(0, sizeof(SdCardManager::SD_1_MOUNT_POINT))
+  } else if (path.substr(0, sizeof(SdCardManager::SD_1_MOUNT_POINT)) ==
-            == std::string(SdCardManager::SD_1_MOUNT_POINT)) {
+             std::string(SdCardManager::SD_1_MOUNT_POINT)) {
     if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
       sif::warning << "FilesystemHelper::checkPath: SD card 1 not mounted" << std::endl;
       return SD_NOT_MOUNTED;

bsp_q7s/memory/FilesystemHelper.h

@@ -2,8 +2,9 @@
 #define BSP_Q7S_MEMORY_FILESYSTEMHELPER_H_
 
 #include <string>
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
 #include "commonClassIds.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 /**
  * @brief   This class implements often used functions concerning the file system management.
@@ -12,7 +13,6 @@
  */
 class FilesystemHelper : public HasReturnvaluesIF {
  public:
-
   static const uint8_t INTERFACE_ID = CLASS_ID::FILE_SYSTEM_HELPER;
 
   //! [EXPORT] : [COMMENT] SD card specified with path string not mounted

linux/devices/devicedefinitions/PlocMPSoCDefinitions.h

@@ -1,13 +1,12 @@
 #ifndef MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
 #define MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
 
+#include "MPSoCReturnValuesIF.h"
+#include "OBSWConfig.h"
+#include "eive/definitions.h"
 #include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/serialize/SerializeAdapter.h"
 #include "fsfw/tmtcpacket/SpacePacket.h"
-#include "eive/definitions.h"
-
-#include "MPSoCReturnValuesIF.h"
-#include "OBSWConfig.h"
 
 namespace mpsoc {
 

linux/devices/ploc/PlocMPSoCHandler.h

@@ -2,21 +2,23 @@
 #define BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_
 
 #include <string>
+
+#include "PlocMPSoCHelper.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
-#include "fsfw_hal/linux/uart/UartComIF.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/tmtcservices/SourceSequenceCounter.h"
-#include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
+#include "fsfw_hal/linux/uart/UartComIF.h"
-#include "PlocMPSoCHelper.h"
 #include "linux/devices/devicedefinitions/MPSoCReturnValuesIF.h"
+#include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 
 /**
  * @brief	This is the device handler for the MPSoC of the payload computer.
  *
  * @details The PLOC uses the space packet protocol for communication. On each command the PLOC
  *          answers with at least one acknowledgment and one execution report.
- *          Flight manual: https://egit.irs.uni-stuttgart.de/redmine/projects/eive-flight-manual/wiki/PLOC_MPSoC
+ *          Flight manual:
- *          ICD: https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_TAS-ILH-IRS/ICD-PLOC/ILH&fileid=1030263
+ * https://egit.irs.uni-stuttgart.de/redmine/projects/eive-flight-manual/wiki/PLOC_MPSoC ICD:
+ * https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_TAS-ILH-IRS/ICD-PLOC/ILH&fileid=1030263
  *
  * @note The sequence count in the space packets must be incremented with each received and sent
  *       packet.
@@ -25,7 +27,6 @@
  */
 class PlocMPSoCHandler : public DeviceHandlerBase {
  public:
-
   PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie,
                    PlocMPSoCHelper* plocMPSoCHelper);
   virtual ~PlocMPSoCHandler();
@@ -40,12 +41,11 @@ protected:
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
   ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
   void fillCommandAndReplyMap() override;
-	ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
-				const uint8_t * commandData,size_t commandDataLen) override;
+                                        size_t commandDataLen) override;
-	ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize,
+  ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId,
-			DeviceCommandId_t *foundId, size_t *foundLen) override;
+                             size_t* foundLen) override;
-	ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
-			const uint8_t *packet) override;
   void setNormalDatapoolEntriesInvalid() override;
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
@@ -56,7 +56,6 @@ protected:
   size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
 
  private:
-
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HANDLER;
 
   //! [EXPORT] : [COMMENT] PLOC crc failure in telemetry packet
@@ -71,9 +70,8 @@ private:
   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
+  //! [EXPORT] : [COMMENT] Packet sequence count in received space packet does not match expected
-    //! P1: Expected sequence count
+  //! count P1: Expected sequence count P2: Received sequence count
-    //! P2: Received sequence count
   static const Event MPSOC_HANDLER_SEQ_CNT_MISMATCH = MAKE_EVENT(5, severity::LOW);
 
   //! [EXPORT] : [COMMENT] Received command has file string with invalid length

linux/devices/ploc/PlocSupervisorHandler.cpp

@@ -1,24 +1,28 @@
-#include <sstream>
-#include <string>
-#include <fstream>
-#include <filesystem>
 #include "PlocSupervisorHandler.h"
-#include "OBSWConfig.h"
+
-#include <fsfw/globalfunctions/CRC.h>
 #include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/globalfunctions/CRC.h>
 #include <fsfw/timemanager/Clock.h>
 
+#include <filesystem>
+#include <fstream>
+#include <sstream>
+#include <string>
+
+#include "OBSWConfig.h"
+
 PlocSupervisorHandler::PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid,
-        CookieIF * comCookie) :
+                                             CookieIF* comCookie)
-        DeviceHandlerBase(objectId, uartComIFid, comCookie), hkset(this), bootStatusReport(this), latchupStatusReport(
+    : DeviceHandlerBase(objectId, uartComIFid, comCookie),
-                this) {
+      hkset(this),
+      bootStatusReport(this),
+      latchupStatusReport(this) {
   if (comCookie == NULL) {
     sif::error << "PlocSupervisorHandler: Invalid com cookie" << std::endl;
   }
 }
 
-PlocSupervisorHandler::~PlocSupervisorHandler() {
+PlocSupervisorHandler::~PlocSupervisorHandler() {}
-}
 
 ReturnValue_t PlocSupervisorHandler::initialize() {
   ReturnValue_t result = RETURN_OK;
@@ -37,7 +41,6 @@ ReturnValue_t PlocSupervisorHandler::initialize() {
   return result;
 }
 
-
 void PlocSupervisorHandler::doStartUp() {
 #if OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP == 1
   setMode(MODE_NORMAL);
@@ -46,22 +49,18 @@ void PlocSupervisorHandler::doStartUp(){
 #endif
 }
 
-void PlocSupervisorHandler::doShutDown(){
+void PlocSupervisorHandler::doShutDown() { setMode(_MODE_POWER_DOWN); }
-    setMode(_MODE_POWER_DOWN);
-}
 
-ReturnValue_t PlocSupervisorHandler::buildNormalDeviceCommand(
+ReturnValue_t PlocSupervisorHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
-		DeviceCommandId_t * id) {
   return NOTHING_TO_SEND;
 }
 
-ReturnValue_t PlocSupervisorHandler::buildTransitionDeviceCommand(
+ReturnValue_t PlocSupervisorHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
-		DeviceCommandId_t * id){
   return NOTHING_TO_SEND;
 }
 
-ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(
+ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-		DeviceCommandId_t deviceCommand, const uint8_t * commandData,
+                                                             const uint8_t* commandData,
                                                              size_t commandDataLen) {
   ReturnValue_t result = RETURN_FAILED;
   switch (deviceCommand) {
@@ -326,14 +325,12 @@ void PlocSupervisorHandler::fillCommandAndReplyMap() {
                          PLOC_SPV::SIZE_LATCHUP_STATUS_REPORT);
 }
 
-ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t *start,
+ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t remainingSize,
-        size_t remainingSize, DeviceCommandId_t *foundId, size_t *foundLen) {
+                                                  DeviceCommandId_t* foundId, size_t* foundLen) {
-
   if (nextReplyId == PLOC_SPV::FIRST_MRAM_DUMP) {
     *foundId = PLOC_SPV::FIRST_MRAM_DUMP;
     return parseMramPackets(start, remainingSize, foundLen);
-    }
+  } else if (nextReplyId == PLOC_SPV::CONSECUTIVE_MRAM_DUMP) {
-    else if (nextReplyId == PLOC_SPV::CONSECUTIVE_MRAM_DUMP) {
     *foundId = PLOC_SPV::CONSECUTIVE_MRAM_DUMP;
     return parseMramPackets(start, remainingSize, foundLen);
   }
@@ -383,7 +380,6 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t *start,
 
 ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
                                                           const uint8_t* packet) {
-
   ReturnValue_t result = RETURN_OK;
 
   switch (id) {
@@ -412,7 +408,8 @@ ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
       break;
     }
     default: {
-        sif::debug << "PlocSupervisorHandler::interpretDeviceReply: Unknown device reply id" << std::endl;
+      sif::debug << "PlocSupervisorHandler::interpretDeviceReply: Unknown device reply id"
+                 << std::endl;
       return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
     }
   }
@@ -420,17 +417,12 @@ ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
   return result;
 }
 
-void PlocSupervisorHandler::setNormalDatapoolEntriesInvalid(){
+void PlocSupervisorHandler::setNormalDatapoolEntriesInvalid() {}
 
-}
+uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
-
-uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo){
-    return 500;
-}
 
 ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                              LocalDataPoolManager& poolManager) {
-
   localDataPoolMap.emplace(PLOC_SPV::NUM_TMS, new PoolEntry<uint32_t>({0}));
   localDataPoolMap.emplace(PLOC_SPV::TEMP_PS, new PoolEntry<uint32_t>({0}));
   localDataPoolMap.emplace(PLOC_SPV::TEMP_PL, new PoolEntry<uint32_t>({0}));
@@ -474,9 +466,9 @@ ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool
 }
 
 ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::iterator command,
-                uint8_t expectedReplies, bool useAlternateId,
+                                                           uint8_t expectedReplies,
+                                                           bool useAlternateId,
                                                            DeviceCommandId_t alternateReplyID) {
-
   ReturnValue_t result = RETURN_OK;
 
   uint8_t enabledReplies = 0;
@@ -581,15 +573,15 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite
    * Every command causes at least one acknowledgment and one execution report. Therefore both
    * replies will be enabled here.
    */
-    result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
+  result =
-            PLOC_SPV::ACK_REPORT);
+      DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, PLOC_SPV::ACK_REPORT);
   if (result != RETURN_OK) {
     sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
                << PLOC_SPV::ACK_REPORT << " not in replyMap" << std::endl;
   }
 
-    result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
+  result =
-            PLOC_SPV::EXE_REPORT);
+      DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, PLOC_SPV::EXE_REPORT);
   if (result != RETURN_OK) {
     sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
                << PLOC_SPV::EXE_REPORT << " not in replyMap" << std::endl;
@@ -608,7 +600,6 @@ ReturnValue_t PlocSupervisorHandler::verifyPacket(const uint8_t* start, size_t f
 }
 
 ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
-
   ReturnValue_t result = RETURN_OK;
 
   result = verifyPacket(data, PLOC_SPV::SIZE_ACK_REPORT);
@@ -627,7 +618,8 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
   switch (apid) {
     case PLOC_SPV::APID_ACK_FAILURE: {
       // TODO: Interpretation of status field in acknowledgment report
-       sif::debug << "PlocSupervisorHandler::handleAckReport: Received Ack failure report" << std::endl;
+      sif::debug << "PlocSupervisorHandler::handleAckReport: Received Ack failure report"
+                 << std::endl;
       DeviceCommandId_t commandId = getPendingCommand();
       if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
         triggerEvent(SUPV_ACK_FAILURE, commandId);
@@ -643,7 +635,8 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
       break;
     }
     default: {
-       sif::debug << "PlocSupervisorHandler::handleAckReport: Invalid APID in Ack report" << std::endl;
+      sif::debug << "PlocSupervisorHandler::handleAckReport: Invalid APID in Ack report"
+                 << std::endl;
       result = RETURN_FAILED;
       break;
     }
@@ -653,7 +646,6 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
 }
 
 ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data) {
-
   ReturnValue_t result = RETURN_OK;
 
   result = verifyPacket(data, PLOC_SPV::SIZE_EXE_REPORT);
@@ -671,14 +663,15 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data)
     }
     case (PLOC_SPV::APID_EXE_FAILURE): {
       // TODO: Interpretation of status field in execution report
-        sif::error << "PlocSupervisorHandler::handleExecutionReport: Received execution failure report"
+      sif::error
+          << "PlocSupervisorHandler::handleExecutionReport: Received execution failure report"
           << std::endl;
       DeviceCommandId_t commandId = getPendingCommand();
       if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
         triggerEvent(SUPV_EXE_FAILURE, commandId);
-        }
+      } else {
-        else {
+        sif::debug << "PlocSupervisorHandler::handleExecutionReport: Unknown command id"
-            sif::debug << "PlocSupervisorHandler::handleExecutionReport: Unknown command id" << std::endl;
+                   << std::endl;
       }
       sendFailureReport(PLOC_SPV::EXE_REPORT, RECEIVED_EXE_FAILURE);
       disableExeReportReply();
@@ -698,43 +691,41 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data)
 }
 
 ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
-
   ReturnValue_t result = RETURN_OK;
 
   result = verifyPacket(data, PLOC_SPV::SIZE_HK_REPORT);
 
   if (result == CRC_FAILURE) {
-        sif::error << "PlocSupervisorHandler::handleHkReport: Hk report has invalid crc"
+    sif::error << "PlocSupervisorHandler::handleHkReport: Hk report has invalid crc" << std::endl;
-                << std::endl;
   }
 
   uint16_t offset = PLOC_SPV::DATA_FIELD_OFFSET;
-    hkset.tempPs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
+  hkset.tempPs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
-            | *(data + offset + 3);
+                 *(data + offset + 3);
   offset += 4;
-    hkset.tempPl = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
+  hkset.tempPl = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
-            | *(data + offset + 3);
+                 *(data + offset + 3);
   offset += 4;
-    hkset.tempSup = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
+  hkset.tempSup = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
-            | *(data + offset + 3);
+                  *(data + offset + 3);
   offset += 4;
-    hkset.uptime = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
+  hkset.uptime = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
-            | *(data + offset + 3);
+                 *(data + offset + 3);
   offset += 4;
-    hkset.cpuLoad = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
+  hkset.cpuLoad = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
-            | *(data + offset + 3);
+                  *(data + offset + 3);
   offset += 4;
-    hkset.availableHeap = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
+  hkset.availableHeap = *(data + offset) << 24 | *(data + offset + 1) << 16 |
-            | *(data + offset + 3);
+                        *(data + offset + 2) << 8 | *(data + offset + 3);
   offset += 4;
-    hkset.numTcs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
+  hkset.numTcs = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
-            | *(data + offset + 3);
+                 *(data + offset + 3);
   offset += 4;
-    hkset.numTms = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
+  hkset.numTms = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
-            | *(data + offset + 3);
+                 *(data + offset + 3);
   offset += 4;
-    hkset.socState = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8
+  hkset.socState = *(data + offset) << 24 | *(data + offset + 1) << 16 | *(data + offset + 2) << 8 |
-            | *(data + offset + 3);
+                   *(data + offset + 3);
   offset += 4;
   hkset.nvm0_1_state = *(data + offset);
   offset += 1;
@@ -753,7 +744,8 @@ ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
   sif::info << "PlocSupervisorHandler::handleHkReport: temp_sup: " << hkset.tempSup << std::endl;
   sif::info << "PlocSupervisorHandler::handleHkReport: uptime: " << hkset.uptime << std::endl;
   sif::info << "PlocSupervisorHandler::handleHkReport: cpu_load: " << hkset.cpuLoad << std::endl;
-    sif::info << "PlocSupervisorHandler::handleHkReport: available_heap: " << hkset.availableHeap << std::endl;
+  sif::info << "PlocSupervisorHandler::handleHkReport: available_heap: " << hkset.availableHeap
+            << std::endl;
   sif::info << "PlocSupervisorHandler::handleHkReport: num_tcs: " << hkset.numTcs << std::endl;
   sif::info << "PlocSupervisorHandler::handleHkReport: num_tms: " << hkset.numTms << std::endl;
   sif::info << "PlocSupervisorHandler::handleHkReport: soc_state: " << hkset.socState << std::endl;
@@ -772,14 +764,14 @@ ReturnValue_t PlocSupervisorHandler::handleHkReport(const uint8_t* data) {
 }
 
 ReturnValue_t PlocSupervisorHandler::handleBootStatusReport(const uint8_t* data) {
-
   ReturnValue_t result = RETURN_OK;
 
   result = verifyPacket(data, PLOC_SPV::SIZE_BOOT_STATUS_REPORT);
 
   if (result == CRC_FAILURE) {
     sif::error << "PlocSupervisorHandler::handleBootStatusReport: Boot status report has invalid"
-                " crc" << std::endl;
+                  " crc"
+               << std::endl;
     return result;
   }
 
@@ -827,7 +819,6 @@ ReturnValue_t PlocSupervisorHandler::handleBootStatusReport(const uint8_t* data)
 }
 
 ReturnValue_t PlocSupervisorHandler::handleLatchupStatusReport(const uint8_t* data) {
-
   ReturnValue_t result = RETURN_OK;
 
   result = verifyPacket(data, PLOC_SPV::SIZE_LATCHUP_STATUS_REPORT);
@@ -913,8 +904,8 @@ ReturnValue_t PlocSupervisorHandler::handleLatchupStatusReport(const uint8_t* da
             << latchupStatusReport.timeYear << std::endl;
   sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: Msec: "
             << latchupStatusReport.timeMsec << std::endl;
-    sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: isSet: 0x"
+  sif::info << "PlocSupervisorHandler::handleLatchupStatusReport: isSet: 0x" << std::hex
-            << std::hex << latchupStatusReport.timeMsec << std::dec << std::endl;
+            << latchupStatusReport.timeMsec << std::dec << std::endl;
 #endif
 
   return result;
@@ -945,15 +936,13 @@ void PlocSupervisorHandler::setNextReplyId() {
 }
 
 size_t PlocSupervisorHandler::getNextReplyLength(DeviceCommandId_t commandId) {
-
   size_t replyLen = 0;
 
   if (nextReplyId == PLOC_SPV::NONE) {
     return replyLen;
   }
 
-    if (nextReplyId == PLOC_SPV::FIRST_MRAM_DUMP
+  if (nextReplyId == PLOC_SPV::FIRST_MRAM_DUMP || nextReplyId == PLOC_SPV::CONSECUTIVE_MRAM_DUMP) {
-            || nextReplyId == PLOC_SPV::CONSECUTIVE_MRAM_DUMP) {
     /**
      * Try to read 20 MRAM packets. If reply is larger, the packets will be read with the
      * next doSendRead call. The command will be as long active as the packet with the sequence
@@ -970,8 +959,7 @@ size_t PlocSupervisorHandler::getNextReplyLength(DeviceCommandId_t commandId){
       return replyLen;
     }
     replyLen = iter->second.replyLen;
-    }
+  } else {
-    else {
     sif::debug << "PlocSupervisorHandler::getNextReplyLength: No entry for reply with reply id "
                << std::hex << nextReplyId << " in deviceReplyMap" << std::endl;
   }
@@ -979,8 +967,8 @@ size_t PlocSupervisorHandler::getNextReplyLength(DeviceCommandId_t commandId){
   return replyLen;
 }
 
-void PlocSupervisorHandler::handleDeviceTM(const uint8_t* data, size_t dataSize, DeviceCommandId_t replyId) {
+void PlocSupervisorHandler::handleDeviceTM(const uint8_t* data, size_t dataSize,
-
+                                           DeviceCommandId_t replyId) {
   ReturnValue_t result = RETURN_OK;
 
   if (wiretappingMode == RAW) {
@@ -1035,8 +1023,8 @@ void PlocSupervisorHandler::prepareDisableHk() {
 }
 
 void PlocSupervisorHandler::prepareSetBootTimeoutCmd(const uint8_t* commandData) {
-    uint32_t timeout = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8
+  uint32_t timeout = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8 |
-            | *(commandData + 3);
+                     *(commandData + 3);
   PLOC_SPV::SetBootTimeout packet(timeout);
   packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
 }
@@ -1065,8 +1053,8 @@ ReturnValue_t PlocSupervisorHandler::prepareWatchdogsConfigTimeoutCmd(const uint
   if (watchdog > 2) {
     return INVALID_WATCHDOG;
   }
-    uint32_t timeout = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16
+  uint32_t timeout = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16 |
-            | *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
+                     *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
   if (timeout < 1000 || timeout > 360000) {
     return INVALID_WATCHDOG_TIMEOUT;
   }
@@ -1107,8 +1095,8 @@ ReturnValue_t PlocSupervisorHandler::prepareAutoCalibrateAlertCmd(const uint8_t*
   uint8_t offset = 0;
   uint8_t latchupId = *commandData;
   offset += 1;
-    uint32_t mg = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16
+  uint32_t mg = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16 |
-            | *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
+                *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
   if (latchupId > 6) {
     return INVALID_LATCHUP_ID;
   }
@@ -1133,8 +1121,8 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAlertLimitCmd(const uint8_t* comm
   uint8_t offset = 0;
   uint8_t latchupId = *commandData;
   offset += 1;
-    uint32_t dutycycle = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16
+  uint32_t dutycycle = *(commandData + offset) << 24 | *(commandData + offset + 1) << 16 |
-            | *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
+                       *(commandData + offset + 2) << 8 | *(commandData + offset + 3);
   if (latchupId > 6) {
     return INVALID_LATCHUP_ID;
   }
@@ -1144,8 +1132,8 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAlertLimitCmd(const uint8_t* comm
 }
 
 ReturnValue_t PlocSupervisorHandler::prepareSetAdcSweetPeriodCmd(const uint8_t* commandData) {
-    uint32_t sweepPeriod = *(commandData) << 24 | *(commandData + 1) << 16
+  uint32_t sweepPeriod = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8 |
-            | *(commandData + 2) << 8 | *(commandData + 3);
+                         *(commandData + 3);
   if (sweepPeriod < 21) {
     return SWEEP_PERIOD_TOO_SMALL;
   }
@@ -1170,8 +1158,8 @@ void PlocSupervisorHandler::prepareSetAdcWindowAndStrideCmd(const uint8_t* comma
 }
 
 void PlocSupervisorHandler::prepareSetAdcThresholdCmd(const uint8_t* commandData) {
-    uint32_t threshold = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8
+  uint32_t threshold = *(commandData) << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8 |
-            | *(commandData + 3);
+                       *(commandData + 3);
   PLOC_SPV::SetAdcThreshold packet(threshold);
   packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
 }
@@ -1267,7 +1255,6 @@ void PlocSupervisorHandler::packetToOutBuffer(uint8_t* packetData, size_t fullSi
 }
 
 void PlocSupervisorHandler::disableAllReplies() {
-
   DeviceReplyMap::iterator iter;
 
   /* Disable ack reply */
@@ -1297,7 +1284,6 @@ void PlocSupervisorHandler::disableAllReplies() {
 }
 
 void PlocSupervisorHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status) {
-
   DeviceReplyIter iter = deviceReplyMap.find(replyId);
 
   if (iter == deviceReplyMap.end()) {
@@ -1308,7 +1294,8 @@ void PlocSupervisorHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnV
   DeviceCommandInfo* info = &(iter->second.command->second);
 
   if (info == nullptr) {
-        sif::debug << "PlocSupervisorHandler::sendFailureReport: Reply has no active command" << std::endl;
+    sif::debug << "PlocSupervisorHandler::sendFailureReport: Reply has no active command"
+               << std::endl;
     return;
   }
 
@@ -1359,7 +1346,6 @@ ReturnValue_t PlocSupervisorHandler::parseMramPackets(const uint8_t *packet, siz
 }
 
 ReturnValue_t PlocSupervisorHandler::handleMramDumpPacket(DeviceCommandId_t id) {
-
   ReturnValue_t result = RETURN_FAILED;
 
   // Prepare packet for downlink
@@ -1372,8 +1358,7 @@ ReturnValue_t PlocSupervisorHandler::handleMramDumpPacket(DeviceCommandId_t id)
     }
     handleMramDumpFile(id);
     if (downlinkMramDump == true) {
-            handleDeviceTM(spacePacketBuffer + PLOC_SPV::SPACE_PACKET_HEADER_LENGTH, packetLen - 1,
+      handleDeviceTM(spacePacketBuffer + PLOC_SPV::SPACE_PACKET_HEADER_LENGTH, packetLen - 1, id);
-                    id);
     }
     packetInBuffer = false;
     receivedMramDumpPackets++;
@@ -1418,16 +1403,15 @@ void PlocSupervisorHandler::increaseExpectedMramReplies(DeviceCommandId_t id) {
     return;
   }
   uint8_t sequenceFlags = spacePacketBuffer[2] >> 6;
-    if (sequenceFlags != static_cast<uint8_t>(PLOC_SPV::SequenceFlags::LAST_PKT)
+  if (sequenceFlags != static_cast<uint8_t>(PLOC_SPV::SequenceFlags::LAST_PKT) &&
-            && (sequenceFlags != static_cast<uint8_t>(PLOC_SPV::SequenceFlags::STANDALONE_PKT))) {
+      (sequenceFlags != static_cast<uint8_t>(PLOC_SPV::SequenceFlags::STANDALONE_PKT))) {
     // Command expects at least one MRAM packet more and the execution report
     info->expectedReplies = 2;
     // Wait maximum of 2 cycles for next MRAM packet
     mramReplyInfo->delayCycles = 2;
     // Also adapting delay cycles for execution report
     exeReplyInfo->delayCycles = 3;
-    }
+  } else {
-    else {
     // Command expects the execution report
     info->expectedReplies = 1;
     mramReplyInfo->delayCycles = 0;
@@ -1448,8 +1432,8 @@ ReturnValue_t PlocSupervisorHandler::handleMramDumpFile(DeviceCommandId_t id) {
   uint16_t packetLen = readSpacePacketLength(spacePacketBuffer);
   uint8_t sequenceFlags = readSequenceFlags(spacePacketBuffer);
   if (id == PLOC_SPV::FIRST_MRAM_DUMP) {
-        if (sequenceFlags == static_cast<uint8_t>(PLOC_SPV::SequenceFlags::FIRST_PKT)
+    if (sequenceFlags == static_cast<uint8_t>(PLOC_SPV::SequenceFlags::FIRST_PKT) ||
-                || (sequenceFlags == static_cast<uint8_t>(PLOC_SPV::SequenceFlags::STANDALONE_PKT))) {
+        (sequenceFlags == static_cast<uint8_t>(PLOC_SPV::SequenceFlags::STANDALONE_PKT))) {
       result = createMramDumpFile();
       if (result != RETURN_OK) {
         return result;
@@ -1515,8 +1499,8 @@ ReturnValue_t PlocSupervisorHandler::getTimeStampString(std::string& timeStamp)
                  << std::endl;
     return GET_TIME_FAILURE;
   }
-    timeStamp = std::to_string(time.year) + "-" + std::to_string(time.month) + "-"
+  timeStamp = std::to_string(time.year) + "-" + std::to_string(time.month) + "-" +
-            + std::to_string(time.day) + "--" + std::to_string(time.hour) + "-"
+              std::to_string(time.day) + "--" + std::to_string(time.hour) + "-" +
-            + std::to_string(time.minute) + "-" + std::to_string(time.second);
+              std::to_string(time.minute) + "-" + std::to_string(time.second);
   return RETURN_OK;
 }

linux/devices/ploc/PlocSupervisorHandler.h

@@ -1,11 +1,12 @@
 #ifndef MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
 #define MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
 
-#include "OBSWConfig.h"
-#include <linux/devices/devicedefinitions/PlocSupervisorDefinitions.h>
 #include <bsp_q7s/memory/SdCardManager.h>
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <fsfw_hal/linux/uart/UartComIF.h>
+#include <linux/devices/devicedefinitions/PlocSupervisorDefinitions.h>
+
+#include "OBSWConfig.h"
 
 /**
  * @brief	This is the device handler for the supervisor of the PLOC which is programmed by
@@ -21,7 +22,6 @@
  */
 class PlocSupervisorHandler : public DeviceHandlerBase {
  public:
-
   PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie);
   virtual ~PlocSupervisorHandler();
 
@@ -33,12 +33,11 @@ protected:
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
   ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
   void fillCommandAndReplyMap() override;
-	ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
-				const uint8_t * commandData,size_t commandDataLen) override;
+                                        size_t commandDataLen) override;
-	ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize,
+  ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId,
-			DeviceCommandId_t *foundId, size_t *foundLen) override;
+                             size_t* foundLen) override;
-	ReturnValue_t interpretDeviceReply(DeviceCommandId_t id,
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
-			const uint8_t *packet) override;
   void setNormalDatapoolEntriesInvalid() override;
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
@@ -49,7 +48,6 @@ protected:
   size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
 
  private:
-
   static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_SUPERVISOR_HANDLER;
 
   //! [EXPORT] : [COMMENT] Space Packet received from PLOC supervisor has invalid CRC
@@ -62,25 +60,32 @@ private:
   static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3);
   //! [EXPORT] : [COMMENT] Failed to read current system time
   static const ReturnValue_t GET_TIME_FAILURE = MAKE_RETURN_CODE(0xA4);
-    //! [EXPORT] : [COMMENT] Received command with invalid watchdog parameter. Valid watchdogs are 0 for PS, 1 for PL and 2 for INT
+  //! [EXPORT] : [COMMENT] Received command with invalid watchdog parameter. Valid watchdogs are 0
+  //! for PS, 1 for PL and 2 for INT
   static const ReturnValue_t INVALID_WATCHDOG = MAKE_RETURN_CODE(0xA5);
-    //! [EXPORT] : [COMMENT] Received watchdog timeout config command with invalid timeout. Valid timeouts must be in the range between 1000 and 360000 ms.
+  //! [EXPORT] : [COMMENT] Received watchdog timeout config command with invalid timeout. Valid
+  //! timeouts must be in the range between 1000 and 360000 ms.
   static const ReturnValue_t INVALID_WATCHDOG_TIMEOUT = MAKE_RETURN_CODE(0xA6);
   //! [EXPORT] : [COMMENT] Received latchup config command with invalid latchup ID
   static const ReturnValue_t INVALID_LATCHUP_ID = MAKE_RETURN_CODE(0xA7);
-    //! [EXPORT] : [COMMENT] Received set adc sweep period command with invalid sweep period. Must be larger than 21.
+  //! [EXPORT] : [COMMENT] Received set adc sweep period command with invalid sweep period. Must be
+  //! larger than 21.
   static const ReturnValue_t SWEEP_PERIOD_TOO_SMALL = MAKE_RETURN_CODE(0xA8);
-    //! [EXPORT] : [COMMENT] Receive auto EM test command with invalid test param. Valid params are 1 and 2.
+  //! [EXPORT] : [COMMENT] Receive auto EM test command with invalid test param. Valid params are 1
+  //! and 2.
   static const ReturnValue_t INVALID_TEST_PARAM = MAKE_RETURN_CODE(0xA9);
   //! [EXPORT] : [COMMENT] Returned when scanning for MRAM dump packets failed.
   static const ReturnValue_t MRAM_PACKET_PARSING_FAILURE = MAKE_RETURN_CODE(0xAA);
-    //! [EXPORT] : [COMMENT] Returned when the start and stop addresses of the MRAM dump or MRAM  wipe commands are invalid (e.g. start address bigger than stop address)
+  //! [EXPORT] : [COMMENT] Returned when the start and stop addresses of the MRAM dump or MRAM  wipe
+  //! commands are invalid (e.g. start address bigger than stop address)
   static const ReturnValue_t INVALID_MRAM_ADDRESSES = MAKE_RETURN_CODE(0xAB);
-    //! [EXPORT] : [COMMENT] Expect reception of an MRAM dump packet but received space packet with other apid.
+  //! [EXPORT] : [COMMENT] Expect reception of an MRAM dump packet but received space packet with
+  //! other apid.
   static const ReturnValue_t NO_MRAM_PACKET = MAKE_RETURN_CODE(0xAC);
   //! [EXPORT] : [COMMENT] Path to PLOC directory on SD card does not exist
   static const ReturnValue_t PATH_DOES_NOT_EXIST = MAKE_RETURN_CODE(0xAD);
-    //! [EXPORT] : [COMMENT] MRAM dump file does not exists. The file should actually already have been created with the reception of the first dump packet.
+  //! [EXPORT] : [COMMENT] MRAM dump file does not exists. The file should actually already have
+  //! been created with the reception of the first dump packet.
   static const ReturnValue_t MRAM_FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xAE);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_SUPERVISOR_HANDLER;
@@ -256,7 +261,6 @@ private:
   void prepareSetGpioCmd(const uint8_t* commandData);
   void prepareReadGpioCmd(const uint8_t* commandData);
 
-
   /**
    * @brief   Copies the content of a space packet to the command buffer.
    */

linux/devices/ploc/PlocUpdater.h

@@ -1,11 +1,10 @@
 #ifndef MISSION_DEVICES_PLOCUPDATER_H_
 #define MISSION_DEVICES_PLOCUPDATER_H_
 
-#include "OBSWConfig.h"
 #include <linux/devices/devicedefinitions/PlocSupervisorDefinitions.h>
-#include "fsfw/action/CommandActionHelper.h"
+
+#include "OBSWConfig.h"
 #include "bsp_q7s/memory/SdCardManager.h"
-#include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"
 #include "eive/definitions.h"
 #include "fsfw/action/ActionHelper.h"
 #include "fsfw/action/CommandActionHelper.h"
@@ -15,6 +14,7 @@
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tmtcpacket/SpacePacket.h"
+#include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"
 #include "linux/fsfwconfig/objects/systemObjectList.h"
 
 /**