CMakeLists.txt

@@ -20,6 +20,9 @@ option(EIVE_ADD_JSON_LIB "Add JSON library" ON)
 option(EIVE_SYSROOT_MAGIC "Perform sysroot magic which might not be necessary" OFF)
 option(EIVE_CREATE_UNIQUE_OBSW_BIN "Append username to generated binary name" ON)
 
+set(OBSW_ADD_STAR_TRACKER 0)
+set(OBSW_DEBUG_STARTRACKER 0)
+
 if(NOT FSFW_OSAL)
 	set(FSFW_OSAL linux CACHE STRING "OS for the FSFW.")
 endif()
@@ -71,7 +74,7 @@ set(LIB_JSON_NAME nlohmann_json::nlohmann_json)
 
 # Set path names
 set(FSFW_PATH fsfw)
-set(TEST_PATH test/testtasks)
+set(TEST_PATH test)
 set(UNITTEST_PATH unittest)
 set(LINUX_PATH linux)
 set(COMMON_PATH common)
@@ -118,6 +121,8 @@ if(TGT_BSP)
         # Used by configure file
         set(EGSE ON)
         set(FSFW_HAL_LINUX_ADD_LIBGPIOD OFF)
+        set(OBSW_ADD_STAR_TRACKER 1)
+        set(OBSW_DEBUG_STARTRACKER 1)
     endif()
     
     if(TGT_BSP MATCHES "arm/beagleboneblack")
@@ -205,7 +210,7 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
 	set(COMPILER_FLAGS "/permissive-")
 endif()
 
-if (NOT(TGT_BSP MATCHES "arm/te0720-1cfa"))
+if (NOT(TGT_BSP MATCHES "arm/te0720-1cfa") AND NOT(TGT_BSP MATCHES "arm/q7s"))
 # Not installed, so use FetchContent to download and provide Catch2
 if(NOT Catch2_FOUND)
     message(STATUS "Did not find a valid Catch2 installation. Using FetchContent to install it")

README.md

@@ -385,20 +385,7 @@ more recent disitributions anymore.
 ## <a id="arm-toolchain"></a> Installing toolchain without Vivado
 
 You can download the toolchains for Windows and Linux
-[from the EIVE cloud](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files?dir=/EIVE_IRS/Software/tools&fileid=831898).
+[from the EIVE cloud](https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/Software/tools).
-
-If `wget` is available (e.g. MinGW64), you can use the following command to download the
-toolchain for Windows
-
-```sh
-wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/rfoaistRd67yBbH/download/gcc-arm-linux-gnueabi-win.zip
-```
-
-or the following command for Linux (could be useful for CI/CD)
-
-```sh
-wget https://eive-cloud.irs.uni-stuttgart.de/index.php/s/MRaeA2XnMXpZ5Pp/download/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf.tar.xz
-```
 
 ## Installing CMake and MSYS2 on Windows
 

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_linux_board/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"
 
 #ifdef RASPBERRY_PI
 static const char* const BOARD_NAME = "Raspberry Pi";
@@ -22,8 +22,7 @@ int main(void) {
   std::cout << "-- EIVE OBSW --" << std::endl;
   std::cout << "-- Compiled for Linux board " << BOARD_NAME << " --" << std::endl;
   std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION << "."
-            << SW_REVISION << ", FSFW v" << fsfw::FSFW_VERSION
+            << SW_REVISION << ", FSFW v" << fsfw::FSFW_VERSION << "--" << std::endl;
-            << "--" << std::endl;
   std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
 
   initmission::initMission();

bsp_q7s/boardconfig/busConf.h

@@ -94,6 +94,9 @@ static constexpr char PL_PCDU_ENABLE_HPA[] = "enable_plpcdu_hpa";
 static constexpr char PL_PCDU_ENABLE_MPA[] = "enable_plpcdu_mpa";
 static constexpr char PL_PCDU_ADC_CS[] = "plpcdu_adc_chip_select";
 
+static constexpr char ENABLE_SUPV_UART[] = "enable_supv_uart";
+static constexpr char ENABLE_MPSOC_UART[] = "enable_mpsoc_uart";
+
 }  // namespace gpioNames
 }  // namespace q7s
 

bsp_q7s/core/InitMission.cpp

@@ -55,14 +55,12 @@ void initmission::initTasks() {
   void (*missedDeadlineFunc)(void) = nullptr;
 #endif
 
-#if BOARD_TE0720 == 0
   PeriodicTaskIF* coreController = factory->createPeriodicTask(
       "CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
   result = coreController->addComponent(objects::CORE_CONTROLLER);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
   }
-#endif
 
   /* TMTC Distribution */
   PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
@@ -140,7 +138,6 @@ void initmission::initTasks() {
     initmission::printAddObjectError("TCS_BOARD_ASS", objects::TCS_BOARD_ASS);
   }
 
-#if BOARD_TE0720 == 0
   // FS task, task interval does not matter because it runs in permanent loop, priority low
   // because it is a non-essential background task
   PeriodicTaskIF* fsTask = factory->createPeriodicTask(
@@ -159,8 +156,6 @@ void initmission::initTasks() {
   }
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 
-#endif /* BOARD_TE0720 */
-
 #if OBSW_ADD_PLOC_MPSOC == 1
   PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask(
       "PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
@@ -212,9 +207,7 @@ void initmission::initTasks() {
   pdecHandlerTask->startTask();
 #endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
 
-#if BOARD_TE0720 == 0
   coreController->startTask();
-#endif
 
   taskStarter(pstTasks, "PST task vector");
   taskStarter(pusTasks, "PUS task vector");
@@ -226,12 +219,10 @@ void initmission::initTasks() {
   ptmeTestTask->startTask();
 #endif
 
-#if BOARD_TE0720 == 0
   fsTask->startTask();
 #if OBSW_ADD_STAR_TRACKER == 1
   strHelperTask > startTask();
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
-#endif
 
 #if OBSW_ADD_ACS_HANDLERS == 1
   acsTask->startTask();
@@ -245,15 +236,16 @@ void initmission::createPstTasks(TaskFactory& factory,
                                  TaskDeadlineMissedFunction missedDeadlineFunc,
                                  std::vector<PeriodicTaskIF*>& taskVec) {
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-#if BOARD_TE0720 == 0
   /* Polling Sequence Table Default */
 #if OBSW_ADD_SPI_TEST_CODE == 0
   FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
       "PST_TASK_DEFAULT", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
   result = pst::pstSpi(spiPst);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
-      sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+      sif::warning << "InitMission::initTasks: SPI PST is empty" << std::endl;
+    } else {
+      sif::error << "InitMission::initTasks: Creating SPI PST failed!" << std::endl;
     }
   } else {
     taskVec.push_back(spiPst);
@@ -264,43 +256,51 @@ void initmission::createPstTasks(TaskFactory& factory,
       "UART_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
   result = pst::pstUart(uartPst);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::warning << "InitMission::initTasks: UART PST is empty" << std::endl;
+    } else {
+      sif::error << "InitMission::initTasks: Creating UART PST failed!" << std::endl;
     }
+  } else {
     taskVec.push_back(uartPst);
+  }
+
   FixedTimeslotTaskIF* gpioPst = factory.createFixedTimeslotTask(
       "GPIO_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
   result = pst::pstGpio(gpioPst);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::warning << "InitMission::initTasks: GPIO PST is empty" << std::endl;
+    } else {
+      sif::error << "InitMission::initTasks: Creating GPIO PST failed!" << std::endl;
     }
+  } else {
     taskVec.push_back(gpioPst);
-
+  }
 #if OBSW_ADD_I2C_TEST_CODE == 0
   FixedTimeslotTaskIF* i2cPst = factory.createFixedTimeslotTask(
       "I2C_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
   result = pst::pstI2c(i2cPst);
   if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::warning << "InitMission::initTasks: I2C PST is empty" << std::endl;
+    } else {
+      sif::error << "InitMission::initTasks: Creating I2C PST failed!" << std::endl;
     }
+  } else {
     taskVec.push_back(i2cPst);
+  }
 #endif
 
   FixedTimeslotTaskIF* gomSpacePstTask = factory.createFixedTimeslotTask(
       "GS_PST_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
   result = pst::pstGompaceCan(gomSpacePstTask);
   if (result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
       sif::error << "InitMission::initTasks: GomSpace PST initialization failed!" << std::endl;
     }
-  taskVec.push_back(gomSpacePstTask);
-#else  /* BOARD_TE7020 == 0 */
-  FixedTimeslotTaskIF* pollingSequenceTaskTE0720 = factory.createFixedTimeslotTask(
-      "PST_TASK_TE0720", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE * 8, 3.0, missedDeadlineFunc);
-  result = pst::pollingSequenceTE0720(pollingSequenceTaskTE0720);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "InitMission::initTasks: Creating TE0720 PST failed!" << std::endl;
   }
-  taskVec.push_back(pollingSequenceTaskTE0720);
+  taskVec.push_back(gomSpacePstTask);
-#endif /* BOARD_TE7020 == 1 */
 }
 
 void initmission::createPusTasks(TaskFactory& factory,
@@ -407,12 +407,6 @@ void initmission::createTestTasks(TaskFactory& factory,
   }
 #endif
 
-#if BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1
-  result = testTask->addComponent(objects::LIBGPIOD_TEST);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
-  }
-#endif /* BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1 */
   taskVec.push_back(testTask);
 
 #endif  // OBSW_ADD_TEST_TASK == 1 && OBSW_ADD_TEST_CODE == 1

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"
@@ -55,6 +55,7 @@
 #include "fsfw/tmtcservices/CommandingServiceBase.h"
 #include "fsfw/tmtcservices/PusServiceBase.h"
 #include "fsfw_hal/common/gpio/GpioCookie.h"
+#include "fsfw_hal/common/gpio/gpioDefinitions.h"
 #include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
 #include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h"
 #include "fsfw_hal/devicehandlers/MgmRM3100Handler.h"
@@ -135,7 +136,6 @@ void ObjectFactory::produce(void* args) {
   PowerSwitchIF* pwrSwitcher = nullptr;
   createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiComIF, &i2cComIF);
   createTmpComponents();
-#if BOARD_TE0720 == 0
   new CoreController(objects::CORE_CONTROLLER);
 
   gpioCallbacks::disableAllDecoder();
@@ -154,6 +154,7 @@ void ObjectFactory::produce(void* args) {
   createSyrlinksComponents();
 #endif /* OBSW_ADD_SYRLINKS == 1 */
   createRtdComponents(gpioComIF, pwrSwitcher);
+  createPayloadComponents(gpioComIF);
 
 #if OBSW_ADD_MGT == 1
   I2cCookie* imtqI2cCookie =
@@ -161,8 +162,8 @@ void ObjectFactory::produce(void* args) {
   auto imtqHandler = new IMTQHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie);
   static_cast<void>(imtqHandler);
 #if OBSW_DEBUG_IMTQ == 1
-  imtqHandler->setToGoToNormal(true);
   imtqHandler->setStartUpImmediately();
+  imtqHandler->setToGoToNormal(true);
 #else
   (void)imtqHandler;
 #endif
@@ -181,26 +182,6 @@ void ObjectFactory::produce(void* args) {
 #endif
 #endif
 
-#if OBSW_ADD_PLOC_MPSOC == 1
-	UartCookie* plocMpsocCookie = new UartCookie(objects::PLOC_MPSOC_HANDLER,
-			q7s::UART_PLOC_MPSOC_DEV, 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,
-			objects::UART_COM_IF, plocMpsocCookie, plocMpsocHelper);
-	plocMPSoCHandler->setStartUpImmediately();
-#endif /* OBSW_ADD_PLOC_MPSOC == 1 */
-
-#if OBSW_ADD_PLOC_SUPERVISOR == 1
-  UartCookie* plocSupervisorCookie = new UartCookie(
-      objects::PLOC_SUPERVISOR_HANDLER, q7s::UART_PLOC_SUPERVSIOR_DEV, UartModes::NON_CANONICAL,
-      uart::PLOC_SUPERVISOR_BAUD, PLOC_SPV::MAX_PACKET_SIZE * 20);
-  plocSupervisorCookie->setNoFixedSizeReply();
-  PlocSupervisorHandler* plocSupervisor = new PlocSupervisorHandler(
-      objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, plocSupervisorCookie);
-  plocSupervisor->setStartUpImmediately();
-#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
-
   new FileSystemHandler(objects::FILE_SYSTEM_HANDLER);
 
 #if OBSW_ADD_STAR_TRACKER == 1
@@ -215,8 +196,6 @@ void ObjectFactory::produce(void* args) {
 
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 
-#endif /* TE7020 == 0 */
-
 #if OBSW_USE_CCSDS_IP_CORE == 1
   createCcsdsComponents(gpioComIF);
 #endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
@@ -231,17 +210,10 @@ void ObjectFactory::produce(void* args) {
 }
 
 void ObjectFactory::createTmpComponents() {
-#if BOARD_TE0720 == 1
-  I2cCookie* i2cCookieTmp1075tcs1 =
-      new I2cCookie(addresses::TMP1075_TCS_1, TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-0"));
-  I2cCookie* i2cCookieTmp1075tcs2 =
-      new I2cCookie(addresses::TMP1075_TCS_2, TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-0"));
-#else
   I2cCookie* i2cCookieTmp1075tcs1 =
       new I2cCookie(addresses::TMP1075_TCS_1, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV);
   I2cCookie* i2cCookieTmp1075tcs2 =
       new I2cCookie(addresses::TMP1075_TCS_2, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV);
-#endif
 
   /* Temperature sensors */
   Tmp1075Handler* tmp1075Handler_1 =
@@ -266,10 +238,8 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, Ua
   *uartComIF = new UartComIF(objects::UART_COM_IF);
   *spiComIF = new SpiComIF(objects::SPI_COM_IF, *gpioComIF);
 
-#if BOARD_TE0720 == 0
   /* Adding gpios for chip select decoding to the gpioComIf */
   gpioCallbacks::initSpiCsDecoder(*gpioComIF);
-#endif
 }
 
 void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher) {
@@ -921,6 +891,7 @@ void ObjectFactory::createRtdComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF
     rtds[idx]->setParent(objects::TCS_BOARD_ASS);
     rtdFdir = new RtdFdir(rtdIds[idx]);
     rtds[idx]->setCustomFdir(rtdFdir);
+    rtds[idx]->setDeviceIdx(idx + 3);
   }
 
 #if OBSW_TEST_RTD == 1
@@ -939,6 +910,46 @@ void ObjectFactory::createRtdComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF
 #endif  // OBSW_ADD_RTD_DEVICES == 1
 }
 
+void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF) {
+  using namespace gpio;
+  std::stringstream consumer;
+#if OBSW_ADD_PLOC_MPSOC == 1
+  consumer << "0x" << std::hex << objects::PLOC_MPSOC_HANDLER;
+  auto gpioConfigMPSoC = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_MPSOC_UART, consumer.str(),
+                                               Direction::OUT, Levels::HIGH);
+  auto mpsocGpioCookie = new GpioCookie;
+  mpsocGpioCookie->addGpio(gpioIds::ENABLE_MPSOC_UART, gpioConfigMPSoC);
+  gpioComIF->addGpios(mpsocGpioCookie);
+  auto mpsocCookie =
+      new UartCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV,
+                     UartModes::NON_CANONICAL, uart::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE);
+  mpsocCookie->setNoFixedSizeReply();
+  auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
+  auto plocMPSoC =
+      new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie,
+                           plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF));
+  plocMPSoC->setStartUpImmediately();
+#endif /* OBSW_ADD_PLOC_MPSOC == 1 */
+
+#if OBSW_ADD_PLOC_SUPERVISOR == 1
+  consumer << "0x" << std::hex << objects::PLOC_SUPERVISOR_HANDLER;
+  auto gpioConfigSupv = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_SUPV_UART, consumer.str(),
+                                               Direction::OUT, Levels::HIGH);
+  auto supvGpioCookie = new GpioCookie;
+  supvGpioCookie->addGpio(gpioIds::ENABLE_SUPV_UART, gpioConfigSupv);
+  gpioComIF->addGpios(supvGpioCookie);
+  auto supervisorCookie = new UartCookie(
+      objects::PLOC_SUPERVISOR_HANDLER, q7s::UART_PLOC_SUPERVSIOR_DEV, UartModes::NON_CANONICAL,
+      uart::PLOC_SUPERVISOR_BAUD, PLOC_SPV::MAX_PACKET_SIZE * 20);
+  supervisorCookie->setNoFixedSizeReply();
+  PlocSupervisorHandler* plocSupervisor =
+      new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF,
+                                supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF));
+  plocSupervisor->setStartUpImmediately();
+#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
+  static_cast<void>(consumer);
+}
+
 void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
   using namespace gpio;
   GpioCookie* gpioCookieRw = new GpioCookie;
@@ -1090,9 +1101,15 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
   AxiPtmeConfig* axiPtmeConfig =
       new AxiPtmeConfig(objects::AXI_PTME_CONFIG, q7s::UIO_PTME, q7s::uiomapids::PTME_CONFIG);
   PtmeConfig* ptmeConfig = new PtmeConfig(objects::PTME_CONFIG, axiPtmeConfig);
+#if OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT == 1
+  // Set to high value when not sending via syrlinks
+  static const uint32_t TRANSMITTER_TIMEOUT = 86400000;  // 1 day
+#else
+  static const uint32_t TRANSMITTER_TIMEOUT = 900000;  // 15 minutes
+#endif
   CCSDSHandler* ccsdsHandler = new CCSDSHandler(
       objects::CCSDS_HANDLER, objects::PTME, objects::CCSDS_PACKET_DISTRIBUTOR, ptmeConfig,
-      gpioComIF, gpioIds::RS485_EN_TX_CLOCK, gpioIds::RS485_EN_TX_DATA);
+      gpioComIF, gpioIds::RS485_EN_TX_CLOCK, gpioIds::RS485_EN_TX_DATA, TRANSMITTER_TIMEOUT);
 
   VirtualChannel* vc = nullptr;
   vc = new VirtualChannel(ccsds::VC0, common::VC0_QUEUE_SIZE, objects::CCSDS_HANDLER);
@@ -1117,7 +1134,6 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
   new PdecHandler(objects::PDEC_HANDLER, objects::CCSDS_HANDLER, gpioComIF, gpioIds::PDEC_RESET,
                   q7s::UIO_PDEC_CONFIG_MEMORY, q7s::UIO_PDEC_RAM, q7s::UIO_PDEC_REGISTERS);
 
-#if BOARD_TE0720 == 0
   GpioCookie* gpioRS485Chip = new GpioCookie;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_TX_CLOCK, "RS485 Transceiver",
                                     Direction::OUT, Levels::LOW);
@@ -1135,7 +1151,6 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
   gpioRS485Chip->addGpio(gpioIds::RS485_EN_RX_DATA, gpio);
 
   gpioComIF->addGpios(gpioRS485Chip);
-#endif /* BOARD_TE0720 == 0 */
 }
 
 void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF) {
@@ -1200,103 +1215,7 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF*
 }
 
 void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
-#if BOARD_TE0720 == 0
   new Q7STestTask(objects::TEST_TASK);
-#endif
-
-#if BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1
-#if OBSW_TEST_GPIO_OPEN_BYLABEL == 1
-  /* Configure MIO0 as input */
-  GpiodRegular* testGpio = new GpiodRegular("MIO0", Direction::OUT, 0, "/amba_pl/gpio@41200000", 0);
-#elif OBSW_TEST_GPIO_OPEN_BY_LINE_NAME
-  GpiodRegularByLineName* testGpio =
-      new GpiodRegularByLineName("test-name", "gpio-test", Direction::OUT, 0);
-#else
-  /* Configure MIO0 as input */
-  GpiodRegular* testGpio = new GpiodRegular("gpiochip0", 0, "MIO0", gpio::IN, 0);
-#endif /* OBSW_TEST_GPIO_LABEL == 1 */
-  GpioCookie* gpioCookie = new GpioCookie;
-  gpioCookie->addGpio(gpioIds::TEST_ID_0, testGpio);
-  new LibgpiodTest(objects::LIBGPIOD_TEST, objects::GPIO_IF, gpioCookie);
-#endif
-
-#if BOARD_TE0720 == 1 && OBSW_TEST_SUS == 1
-  GpioCookie* gpioCookieSus = new GpioCookie;
-  GpiodRegular* chipSelectSus = new GpiodRegular(
-      std::string("gpiochip1"), 9, std::string("Chip Select Sus Sensor"), Direction::OUT, 1);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_0, chipSelectSus);
-  gpioComIF->addGpios(gpioCookieSus);
-
-  SpiCookie* spiCookieSus =
-      new SpiCookie(addresses::SUS_0, std::string("/dev/spidev1.0"), SUS::MAX_CMD_SIZE,
-                    spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
-
-  new SusHandler(objects::SUS_0, objects::SPI_COM_IF, spiCookieSus, gpioComIF, gpioIds::CS_SUS_0);
-#endif
-
-#if BOARD_TE0720 == 1 && OBSW_TEST_CCSDS_BRIDGE == 1
-  GpioCookie* gpioCookieCcsdsIp = new GpioCookie;
-  GpiodRegular* papbBusyN =
-      new GpiodRegular(std::string("gpiochip0"), 0, std::string("PAPBBusy_VC0"));
-  gpioCookieCcsdsIp->addGpio(gpioIds::PAPB_BUSY_N, papbBusyN);
-  GpiodRegular* papbEmpty =
-      new GpiodRegular(std::string("gpiochip0"), 1, std::string("PAPBEmpty_VC0"));
-  gpioCookieCcsdsIp->addGpio(gpioIds::PAPB_EMPTY, papbEmpty);
-  gpioComIF->addGpios(gpioCookieCcsdsIp);
-
-  new CCSDSIPCoreBridge(objects::CCSDS_IP_CORE_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR,
-                        objects::TM_STORE, objects::TC_STORE, gpioComIF, std::string("/dev/uio0"),
-                        gpioIds::PAPB_BUSY_N, gpioIds::PAPB_EMPTY);
-#endif
-
-#if BOARD_TE0720 == 1 && OBSW_TEST_RAD_SENSOR == 1
-  GpioCookie* gpioCookieRadSensor = new GpioCookie;
-  GpiodRegular* chipSelectRadSensor = new GpiodRegular(
-      std::string("gpiochip1"), 0, std::string("Chip select radiation sensor"), Direction::OUT, 1);
-  gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, chipSelectRadSensor);
-  gpioComIF->addGpios(gpioCookieRadSensor);
-
-  SpiCookie* spiCookieRadSensor =
-      new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, std::string("/dev/spidev1.0"),
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
-
-  RadiationSensorHandler* radSensor =
-      new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_COM_IF, spiCookieRadSensor);
-  radSensor->setStartUpImmediately();
-#endif
-
-#if BOARD_TE0720 == 1 && OBSW_ADD_PLOC_MPSOC == 1
-  UartCookie* mpsocUartCookie =
-      new UartCookie(objects::PLOC_MPSOC_HANDLER, std::string("/dev/ttyPS2"),
-                     UartModes::NON_CANONICAL, 115200, mpsoc::MAX_REPLY_SIZE);
-  /* Testing PlocMPSoCHandler on TE0720-03-1CFA */
-  PlocMPSoCHelper* plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
-  PlocMPSoCHandler* plocMPSoCHandler = new PlocMPSoCHandler(
-      objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocUartCookie, plocMpsocHelper);
-  plocMPSoCHandler->setStartUpImmediately();
-#endif
-
-#if BOARD_TE0720 == 1 && OBSW_TEST_TE7020_HEATER == 1
-  /* Configuration for MIO0 on TE0720-03-1CFA */
-  GpiodRegular* heaterGpio =
-      new GpiodRegular(std::string("gpiochip0"), 0, std::string("MIO0"), gpio::IN, 0);
-  GpioCookie* gpioCookie = new GpioCookie;
-  gpioCookie->addGpio(gpioIds::HEATER_0, heaterGpio);
-  new HeaterHandler(objects::HEATER_HANDLER, objects::GPIO_IF, gpioCookie, objects::PCDU_HANDLER,
-                    pcduSwitches::TCS_BOARD_8V_HEATER_IN);
-#endif
-
-#if BOARD_TE0720 == 1 && OBSW_ADD_PLOC_SUPERVISOR == 1
-  /* Configuration for MIO0 on TE0720-03-1CFA */
-  UartCookie* plocSupervisorCookie =
-      new UartCookie(objects::PLOC_SUPERVISOR_HANDLER, std::string("/dev/ttyPS1"),
-                     UartModes::NON_CANONICAL, 115200, PLOC_SPV::MAX_PACKET_SIZE * 20);
-  plocSupervisorCookie->setNoFixedSizeReply();
-  PlocSupervisorHandler* plocSupervisor = new PlocSupervisorHandler(
-      objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, plocSupervisorCookie);
-  plocSupervisor->setStartUpImmediately();
-#endif
-
 #if OBSW_ADD_SPI_TEST_CODE == 1
   new SpiTestClass(objects::SPI_TEST, gpioComIF);
 #endif

bsp_q7s/core/ObjectFactory.h

@@ -26,6 +26,7 @@ void createHeaterComponents();
 void createSolarArrayDeploymentComponents();
 void createSyrlinksComponents();
 void createRtdComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher);
+void createPayloadComponents(LinuxLibgpioIF* gpioComIF);
 void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF);
 void createCcsdsComponents(LinuxLibgpioIF* gpioComIF);
 void createTestComponents(LinuxLibgpioIF* gpioComIF);

bsp_q7s/core/obsw.cpp

@@ -15,7 +15,7 @@ static int OBSW_ALREADY_RUNNING = -2;
 int obsw::obsw() {
   using namespace fsfw;
   std::cout << "-- EIVE OBSW --" << std::endl;
-#if BOARD_TE0720 == 0
+#ifdef TE0720_1CFA
   std::cout << "-- Compiled for Linux (Xiphos Q7S) --" << std::endl;
 #else
   std::cout << "-- Compiled for Linux (TE0720) --" << std::endl;

bsp_q7s/memory/FileSystemHandler.h

@@ -6,6 +6,7 @@
 
 #include "OBSWConfig.h"
 #include "SdCardManager.h"
+#include "eive/definitions.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/memory/HasFileSystemIF.h"
 #include "fsfw/objectmanager/SystemObject.h"

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.
@@ -11,8 +12,7 @@
  * @author  J. Meier
  */
 class FilesystemHelper : public HasReturnvaluesIF {
-public:
+ public:
-
   static const uint8_t INTERFACE_ID = CLASS_ID::FILE_SYSTEM_HELPER;
 
   //! [EXPORT] : [COMMENT] SD card specified with path string not mounted

bsp_te0720_1cfa/ObjectFactory.cpp

@@ -1,8 +1,9 @@
 #include "ObjectFactory.h"
 
 #include <devConf.h>
-#include <fsfw_hal/linux/uart/UartComIF.h>
+#include "fsfw_hal/linux/uart/UartComIF.h"
-#include <fsfw_hal/linux/uart/UartCookie.h>
+#include "fsfw_hal/linux/i2c/I2cComIF.h"
+#include "fsfw_hal/linux/uart/UartCookie.h"
 
 #include "OBSWConfig.h"
 #include "busConf.h"
@@ -11,11 +12,16 @@
 #include "fsfw/tmtcpacket/pus/tm.h"
 #include "fsfw/tmtcservices/CommandingServiceBase.h"
 #include "fsfw/tmtcservices/PusServiceBase.h"
+#include "fsfw_hal/linux/i2c/I2cCookie.h"
 #include "linux/devices/ploc/PlocMPSoCHandler.h"
 #include "linux/devices/ploc/PlocMPSoCHelper.h"
+#include "mission/devices/Tmp1075Handler.h"
 #include "mission/core/GenericFactory.h"
 #include "mission/utility/TmFunnel.h"
+#include "test/gpio/DummyGpioIF.h"
 #include "objects/systemObjectList.h"
+#include "devices/addresses.h"
+#include "devices/gpioIds.h"
 #include "tmtc/apid.h"
 #include "tmtc/pusIds.h"
 
@@ -39,12 +45,108 @@ void ObjectFactory::produce(void* args) {
 
 #if OBSW_ADD_PLOC_MPSOC == 1
   UartCookie* mpsocUartCookie =
-      new UartCookie(objects::PLOC_MPSOC_HANDLER, te0720_1cfa::MPSOC_UART,
+      new UartCookie(objects::PLOC_MPSOC_HANDLER, te0720_1cfa::MPSOC_UART, UartModes::NON_CANONICAL,
-                     UartModes::NON_CANONICAL, uart::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE);
+                     uart::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE);
+  mpsocUartCookie->setNoFixedSizeReply();
   PlocMPSoCHelper* plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
   new UartComIF(objects::UART_COM_IF);
-  PlocMPSoCHandler* plocMPSoCHandler = new PlocMPSoCHandler(
+  auto dummyGpioIF = new DummyGpioIF();
-      objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocUartCookie, plocMpsocHelper);
+  PlocMPSoCHandler* plocMPSoCHandler =
+      new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocUartCookie,
+                           plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, dummyGpioIF));
   plocMPSoCHandler->setStartUpImmediately();
 #endif /* OBSW_ADD_PLOC_MPSOC == 1 */
+
+#if OBSW_TEST_LIBGPIOD == 1
+#if OBSW_TEST_GPIO_OPEN_BYLABEL == 1
+  /* Configure MIO0 as input */
+  GpiodRegular* testGpio = new GpiodRegular("MIO0", Direction::OUT, 0, "/amba_pl/gpio@41200000", 0);
+#elif OBSW_TEST_GPIO_OPEN_BY_LINE_NAME
+  GpiodRegularByLineName* testGpio =
+      new GpiodRegularByLineName("test-name", "gpio-test", Direction::OUT, 0);
+#else
+  /* Configure MIO0 as input */
+  GpiodRegular* testGpio = new GpiodRegular("gpiochip0", 0, "MIO0", gpio::IN, 0);
+#endif /* OBSW_TEST_GPIO_LABEL == 1 */
+  GpioCookie* gpioCookie = new GpioCookie;
+  gpioCookie->addGpio(gpioIds::TEST_ID_0, testGpio);
+  new LibgpiodTest(objects::LIBGPIOD_TEST, objects::GPIO_IF, gpioCookie);
+#endif
+
+#if OBSW_TEST_SUS == 1
+  GpioCookie* gpioCookieSus = new GpioCookie;
+  GpiodRegular* chipSelectSus = new GpiodRegular(
+      std::string("gpiochip1"), 9, std::string("Chip Select Sus Sensor"), Direction::OUT, 1);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_0, chipSelectSus);
+  gpioComIF->addGpios(gpioCookieSus);
+
+  SpiCookie* spiCookieSus =
+      new SpiCookie(addresses::SUS_0, std::string("/dev/spidev1.0"), SUS::MAX_CMD_SIZE,
+                    spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
+
+  new SusHandler(objects::SUS_0, objects::SPI_COM_IF, spiCookieSus, gpioComIF, gpioIds::CS_SUS_0);
+#endif
+
+#if OBSW_TEST_CCSDS_BRIDGE == 1
+  GpioCookie* gpioCookieCcsdsIp = new GpioCookie;
+  GpiodRegular* papbBusyN =
+      new GpiodRegular(std::string("gpiochip0"), 0, std::string("PAPBBusy_VC0"));
+  gpioCookieCcsdsIp->addGpio(gpioIds::PAPB_BUSY_N, papbBusyN);
+  GpiodRegular* papbEmpty =
+      new GpiodRegular(std::string("gpiochip0"), 1, std::string("PAPBEmpty_VC0"));
+  gpioCookieCcsdsIp->addGpio(gpioIds::PAPB_EMPTY, papbEmpty);
+  gpioComIF->addGpios(gpioCookieCcsdsIp);
+
+  new CCSDSIPCoreBridge(objects::CCSDS_IP_CORE_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR,
+                        objects::TM_STORE, objects::TC_STORE, gpioComIF, std::string("/dev/uio0"),
+                        gpioIds::PAPB_BUSY_N, gpioIds::PAPB_EMPTY);
+#endif
+
+#if OBSW_TEST_RAD_SENSOR == 1
+  GpioCookie* gpioCookieRadSensor = new GpioCookie;
+  GpiodRegular* chipSelectRadSensor = new GpiodRegular(
+      std::string("gpiochip1"), 0, std::string("Chip select radiation sensor"), Direction::OUT, 1);
+  gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, chipSelectRadSensor);
+  gpioComIF->addGpios(gpioCookieRadSensor);
+
+  SpiCookie* spiCookieRadSensor =
+      new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, std::string("/dev/spidev1.0"),
+                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
+
+  RadiationSensorHandler* radSensor =
+      new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_COM_IF, spiCookieRadSensor);
+  radSensor->setStartUpImmediately();
+#endif
+
+#if OBSW_TEST_TE7020_HEATER == 1
+  /* Configuration for MIO0 on TE0720-03-1CFA */
+  GpiodRegular* heaterGpio =
+      new GpiodRegular(std::string("gpiochip0"), 0, std::string("MIO0"), gpio::IN, 0);
+  GpioCookie* gpioCookie = new GpioCookie;
+  gpioCookie->addGpio(gpioIds::HEATER_0, heaterGpio);
+  new HeaterHandler(objects::HEATER_HANDLER, objects::GPIO_IF, gpioCookie, objects::PCDU_HANDLER,
+                    pcduSwitches::TCS_BOARD_8V_HEATER_IN);
+#endif
+
+#if OBSW_ADD_PLOC_SUPERVISOR == 1
+  /* Configuration for MIO0 on TE0720-03-1CFA */
+  UartCookie* plocSupervisorCookie =
+      new UartCookie(objects::PLOC_SUPERVISOR_HANDLER, std::string("/dev/ttyPS1"),
+                     UartModes::NON_CANONICAL, 115200, PLOC_SPV::MAX_PACKET_SIZE * 20);
+  plocSupervisorCookie->setNoFixedSizeReply();
+  PlocSupervisorHandler* plocSupervisor = new PlocSupervisorHandler(
+      objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, plocSupervisorCookie);
+  plocSupervisor->setStartUpImmediately();
+#endif
+
+new I2cComIF(objects::I2C_COM_IF);
+
+I2cCookie* i2cCookieTmp1075tcs1 =
+  new I2cCookie(addresses::TMP1075_TCS_1, TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-0"));
+I2cCookie* i2cCookieTmp1075tcs2 =
+  new I2cCookie(addresses::TMP1075_TCS_2, TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-0"));
+
+/* Temperature sensors */
+new Tmp1075Handler(objects::TMP1075_HANDLER_1, objects::I2C_COM_IF, i2cCookieTmp1075tcs1);
+new Tmp1075Handler(objects::TMP1075_HANDLER_2, objects::I2C_COM_IF, i2cCookieTmp1075tcs2);
 }

cmake/scripts/Q7S/win-q7s-env.sh

@@ -1,7 +1,7 @@
 #!/bin/sh
-# Run with: source q7s-env-win-sh [OPTIONS]
+# Run with: source win-q7s-env.sh [OPTIONS]
 function help () {
-	echo "source q7s-env-win-sh [options] -t|--toolchain=<toolchain path> -s|--sysroot=<sysroot path>"
+	echo "source win-q7s-env.sh [options] -t|--toolchain=<toolchain path> -s|--sysroot=<sysroot path>"
 }
 
 TOOLCHAIN_PATH="/c/Xilinx/Vitis/2019.2/gnu/aarch32/nt/gcc-arm-linux-gnueabi/bin"

common/config/devices/gpioIds.h

@@ -119,7 +119,11 @@ enum gpioId_t {
   PLPCDU_ENB_TX,
   PLPCDU_ENB_HPA,
   PLPCDU_ENB_MPA,
-  PLPCDU_ADC_CS
+  PLPCDU_ADC_CS,
+
+  ENABLE_MPSOC_UART,
+  ENABLE_SUPV_UART
+
 };
 }
 

common/config/devices/powerSwitcherList.h

@@ -39,7 +39,7 @@ static const uint8_t OFF = 0;
 const std::array<uint8_t, NUMBER_OF_SWITCHES> INIT_SWITCH_STATES = {
     // PDU 1
 // Because the TE0720 is not connected to the PCDU, this switch is always on
-#if BOARD_TE0720 == 1
+#ifdef TE0720_1CFA
     ON,
 #else
     OFF,

common/config/eive/definitions.h

@@ -0,0 +1,25 @@
+#ifndef COMMON_CONFIG_DEFINITIONS_H_
+#define COMMON_CONFIG_DEFINITIONS_H_
+
+#include <cstdint>
+
+namespace config {
+
+static constexpr uint32_t PL_PCDU_TRANSITION_TIMEOUT_MS = 20 * 60 * 1000;
+static constexpr uint32_t LONGEST_MODE_TIMEOUT_SECONDS = PL_PCDU_TRANSITION_TIMEOUT_MS / 1000;
+
+/* Add mission configuration flags here */
+static constexpr uint32_t OBSW_FILESYSTEM_HANDLER_QUEUE_SIZE = 50;
+static constexpr uint32_t PLOC_UPDATER_QUEUE_SIZE = 50;
+static constexpr uint32_t STR_IMG_HELPER_QUEUE_SIZE = 50;
+
+static constexpr uint8_t LIVE_TM = 0;
+
+/* Limits for filename and path checks */
+static constexpr uint32_t MAX_PATH_SIZE = 100;
+static constexpr uint32_t MAX_FILENAME_SIZE = 50;
+
+}
+
+
+#endif /* COMMON_CONFIG_DEFINITIONS_H_ */

fsfw

@@ -1 +1 @@
-Subproject commit bac8b4088009a71afbb0225e634dabcbff0d9ec1
+Subproject commit b52f19254b8072a32203eaab91ea3c65b513ba7e

generators/bsp_q7s_events.csv

@@ -144,16 +144,16 @@
 12016;0x2ef0;STR_HELPER_REQUESTING_MSG_FAILED;LOW;;linux/devices/startracker/StrHelper.h
 12100;0x2f44;MPSOC_FLASH_WRITE_FAILED;LOW;Flash write fails;linux/devices/ploc/PlocMPSoCHelper.h
 12101;0x2f45;MPSOC_FLASH_WRITE_SUCCESSFUL;LOW;Flash write successful;linux/devices/ploc/PlocMPSoCHelper.h
-12102;0x2f46;SENDING_COMMAND_FAILED;LOW;Communication interface returned failure when trying to send the command ot the PLOCP1: Return value returned by the communication interface sendMessage functionP2: Internal state of MPSoC helper;linux/devices/ploc/PlocMPSoCHelper.h
+12102;0x2f46;SENDING_COMMAND_FAILED;LOW;;linux/devices/ploc/PlocMPSoCHelper.h
-12103;0x2f47;MPSOC_HELPER_REQUESTING_REPLY_FAILED;LOW;Request receive message of communication interface failedP1: Return value returned by the communication interface requestReceiveMessage functionP2: Internal state of MPSoC helper;linux/devices/ploc/PlocMPSoCHelper.h
+12103;0x2f47;MPSOC_HELPER_REQUESTING_REPLY_FAILED;LOW;Request receive message of communication interface failed P1: Return value returned by the communication interface requestReceiveMessage function P2: Internal state of MPSoC helper;linux/devices/ploc/PlocMPSoCHelper.h
-12104;0x2f48;MPSOC_HELPER_READING_REPLY_FAILED;LOW;Reading receive message of communication interface failedP1: Return value returned by the communication interface readingReceivedMessage functionP2: Internal state of MPSoC helper;linux/devices/ploc/PlocMPSoCHelper.h
+12104;0x2f48;MPSOC_HELPER_READING_REPLY_FAILED;LOW;Reading receive message of communication interface failed P1: Return value returned by the communication interface readingReceivedMessage function P2: Internal state of MPSoC helper;linux/devices/ploc/PlocMPSoCHelper.h
-12105;0x2f49;MISSING_ACK;LOW;Did not receive acknowledgement reportP1: Number of bytes missingP2: Internal state of MPSoC helper;linux/devices/ploc/PlocMPSoCHelper.h
+12105;0x2f49;MISSING_ACK;LOW;Did not receive acknowledgement report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/devices/ploc/PlocMPSoCHelper.h
-12106;0x2f4a;MISSING_EXE;LOW;Did not receive execution reportP1: Number of bytes missingP2: Internal state of MPSoC helper;linux/devices/ploc/PlocMPSoCHelper.h
+12106;0x2f4a;MISSING_EXE;LOW;Did not receive execution report P1: Number of bytes missing P2: Internal state of MPSoC helper;linux/devices/ploc/PlocMPSoCHelper.h
-12107;0x2f4b;ACK_FAILURE_REPORT;LOW;Received acknowledgement failure reportP1: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h
+12107;0x2f4b;ACK_FAILURE_REPORT;LOW;Received acknowledgement failure report P1: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h
-12108;0x2f4c;EXE_FAILURE_REPORT;LOW;Received execution failure reportP1: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h
+12108;0x2f4c;EXE_FAILURE_REPORT;LOW;Received execution failure report P1: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h
-12109;0x2f4d;ACK_INVALID_APID;LOW;Expected acknowledgement report but received space packet with other apidP1: Apid of received space packetP2: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h
+12109;0x2f4d;ACK_INVALID_APID;LOW;Expected acknowledgement report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h
-12110;0x2f4e;EXE_INVALID_APID;LOW;Expected execution report but received space packet with other apidP1: Apid of received space packetP2: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h
+12110;0x2f4e;EXE_INVALID_APID;LOW;Expected execution report but received space packet with other apid P1: Apid of received space packet P2: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h
-12111;0x2f4f;MPSOC_HELPER_SEQ_CNT_MISMATCH;LOW;Received sequence count does not match expected sequence countP1: Expected sequence countP2: Received sequence count;linux/devices/ploc/PlocMPSoCHelper.h
+12111;0x2f4f;MPSOC_HELPER_SEQ_CNT_MISMATCH;LOW;Received sequence count does not match expected sequence count P1: Expected sequence count P2: Received sequence count;linux/devices/ploc/PlocMPSoCHelper.h
 12200;0x2fa8;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/AcsBoardAssembly.h
 12201;0x2fa9;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/AcsBoardAssembly.h
 12202;0x2faa;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/AcsBoardAssembly.h

generators/bsp_q7s_returnvalues.csv

@@ -470,6 +470,7 @@
 0x57e1;DWLPWRON_InvalidLaneRate;Received command has invalid lane rate (valid lane rate are 0 - 9);0xE1;linux/devices/devicedefinitions/PlocMPSoCDefinitions.h;DWLPWRON_CMD
 0x60a0;PLMEMDUMP_MramAddressTooHigh;The capacity of the MRAM amounts to 512 kB. Thus the maximum address must not be higher than 0x7d000.;0xA0;linux/devices/ploc/PlocMemoryDumper.h;PLOC_MEMORY_DUMPER
 0x60a1;PLMEMDUMP_MramInvalidAddressCombination;The specified end address is lower than the start address;0xA1;linux/devices/ploc/PlocMemoryDumper.h;PLOC_MEMORY_DUMPER
+0x67a0; PLMPHLP_FileClosedAccidentally;File accidentally close;0xA0;linux/devices/ploc/PlocMPSoCHelper.h;PLOC_MPSOC_HELPER
 0x5da0;PLUD_UpdaterBusy;Updater is already performing an update;0xA0;linux/devices/ploc/PlocUpdater.h;PLOC_UPDATER
 0x5da1;PLUD_NameTooLong;Received update command with invalid path string (too long).;0xA1;linux/devices/ploc/PlocUpdater.h;PLOC_UPDATER
 0x5da2;PLUD_SdNotMounted;Received command to initiate update but SD card with update image not mounted.;0xA2;linux/devices/ploc/PlocUpdater.h;PLOC_UPDATER

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
  * @brief    Auto-generated event translation file. Contains 169 translations.
  * @details
- * Generated on: 2022-03-25 18:53:13
+ * Generated on: 2022-03-28 09:51:17
  */
 #include "translateEvents.h"
 

generators/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 117 translations.
- * Generated on: 2022-03-25 18:53:22
+ * Generated on: 2022-03-28 09:51:13
  */
 #include "translateObjects.h"
 

linux/devices/devicedefinitions/MPSoCReturnValuesIF.h

@@ -4,7 +4,7 @@
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 class MPSoCReturnValuesIF {
-public:
+ public:
   static const uint8_t INTERFACE_ID = CLASS_ID::MPSOC_RETURN_VALUES_IF;
 
   //! [EXPORT] : [COMMENT] Space Packet received from PLOC has invalid CRC

linux/devices/devicedefinitions/PlocMPSoCDefinitions.h

@@ -1,11 +1,12 @@
 #ifndef MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
 #define MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
 
-#include "OBSWConfig.h"
 #include "MPSoCReturnValuesIF.h"
-#include <fsfw/tmtcpacket/SpacePacket.h>
+#include "OBSWConfig.h"
-#include <fsfw/globalfunctions/CRC.h>
+#include "eive/definitions.h"
-#include <fsfw/serialize/SerializeAdapter.h>
+#include "fsfw/globalfunctions/CRC.h"
+#include "fsfw/serialize/SerializeAdapter.h"
+#include "fsfw/tmtcpacket/SpacePacket.h"
 
 namespace mpsoc {
 
@@ -37,28 +38,29 @@ static const uint16_t SIZE_TM_MEM_READ_REPORT = 18;
  * SpacePacket apids of PLOC telecommands and telemetry.
  */
 namespace apid {
-    static const uint16_t TC_REPLAY_START = 0x110;
+static const uint16_t TC_REPLAY_START = 0x110;
-    static const uint16_t TC_REPLAY_STOP = 0x111;
+static const uint16_t TC_REPLAY_STOP = 0x111;
-    static const uint16_t TC_REPLAY_WRITE_SEQUENCE = 0x112;
+static const uint16_t TC_REPLAY_WRITE_SEQUENCE = 0x112;
-    static const uint16_t TC_DOWNLINK_PWR_ON = 0x113;
+static const uint16_t TC_DOWNLINK_PWR_ON = 0x113;
-    static const uint16_t TC_MEM_WRITE = 0x114;
+static const uint16_t TC_MEM_WRITE = 0x114;
-    static const uint16_t TC_MEM_READ = 0x115;
+static const uint16_t TC_MEM_READ = 0x115;
-    static const uint16_t TC_FLASHWRITE = 0x117;
+static const uint16_t TC_FLASHWRITE = 0x117;
-    static const uint16_t TC_FLASHFOPEN = 0x119;
+static const uint16_t TC_FLASHFOPEN = 0x119;
-    static const uint16_t TC_FLASHFCLOSE = 0x11A;
+static const uint16_t TC_FLASHFCLOSE = 0x11A;
-    static const uint16_t TC_FLASHDELETE = 0x11C;
+static const uint16_t TC_FLASHDELETE = 0x11C;
-    static const uint16_t TC_MODE_REPLAY = 0x11F;
+static const uint16_t TC_MODE_REPLAY = 0x11F;
-    static const uint16_t TC_DOWNLINK_PWR_OFF = 0x124;
+static const uint16_t TC_DOWNLINK_PWR_OFF = 0x124;
-    static const uint16_t TM_MEMORY_READ_REPORT = 0x404;
+static const uint16_t TM_MEMORY_READ_REPORT = 0x404;
-    static const uint16_t ACK_SUCCESS = 0x400;
+static const uint16_t ACK_SUCCESS = 0x400;
-    static const uint16_t ACK_FAILURE = 0x401;
+static const uint16_t ACK_FAILURE = 0x401;
-    static const uint16_t EXE_SUCCESS = 0x402;
+static const uint16_t EXE_SUCCESS = 0x402;
-    static const uint16_t EXE_FAILURE = 0x403;
+static const uint16_t EXE_FAILURE = 0x403;
-}
+}  // namespace apid
 
 /** Offset from first byte in space packet to first byte of data field */
 static const uint8_t DATA_FIELD_OFFSET = 6;
 static const size_t MEM_READ_RPT_LEN_OFFSET = 10;
+static const char NULL_TERMINATOR = '\0';
 
 /**
  * The size of payload data which will be forwarded to the requesting object. e.g. PUS Service
@@ -81,16 +83,17 @@ static const size_t MAX_DATA_SIZE = 1016;
 
 /**
  * The replay write sequence command has a maximum delay for the execution report which amounts to
- * 30 seconds (60 cycles * 0.5 seconds).
+ * 30 seconds. (80 cycles * 0.5 seconds = 40 seconds).
  */
-static const uint16_t TC_WRITE_SEQ_EXECUTION_DELAY = 60;
+static const uint16_t TC_WRITE_SEQ_EXECUTION_DELAY = 80;
+// Requires approx. 2 seconds for execution. 8 => 4 seconds
+static const uint16_t TC_DOWNLINK_PWR_ON_EXECUTION_DELAY = 8;
 
 /**
  * @brief   Abstract base class for TC space packet of MPSoC.
  */
 class TcBase : public SpacePacket, public MPSoCReturnValuesIF {
-public:
+ public:
-
   // Initial length field of space packet. Will always be updated when packet is created.
   static const uint16_t INIT_LENGTH = 1;
 
@@ -100,9 +103,8 @@ public:
    * @param sequenceCount Sequence count of space packet which will be incremented with each
    *        sent and received packets.
    */
-    TcBase(uint16_t apid, uint16_t sequenceCount) :
+  TcBase(uint16_t apid, uint16_t sequenceCount)
-            SpacePacket(INIT_LENGTH, true, apid, sequenceCount) {
+      : SpacePacket(INIT_LENGTH, true, apid, sequenceCount) {}
-    }
 
   /**
    * @brief   Function to initialize the space packet
@@ -125,7 +127,7 @@ public:
     return result;
   }
 
-protected:
+ protected:
   /**
    * @brief   Must be overwritten by the child class to define the command specific parameters
    *
@@ -144,8 +146,8 @@ protected:
     size_t serializedSize = 0;
     uint32_t full_size = getFullSize();
     uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
-        result = SerializeAdapter::serialize<uint16_t>(&crc,
+    result = SerializeAdapter::serialize<uint16_t>(
-                this->localData.byteStream + full_size - CRC_SIZE, &serializedSize, sizeof(crc),
+        &crc, this->localData.byteStream + full_size - CRC_SIZE, &serializedSize, sizeof(crc),
         SerializeIF::Endianness::BIG);
     if (result != HasReturnvaluesIF::RETURN_OK) {
       sif::debug << "TcBase::addCrc: Failed to serialize crc field" << std::endl;
@@ -158,18 +160,17 @@ protected:
  * @brief   Class for handling tm replies of the PLOC MPSoC.
  */
 class TmPacket : public SpacePacket, public MPSoCReturnValuesIF {
-public:
+ public:
-
   /**
    * @brief   Constructor creates idle packet and sets length field to maximum allowed size.
    */
-    TmPacket() : SpacePacket(PACKET_MAX_SIZE) {
+  TmPacket() : SpacePacket(PACKET_MAX_SIZE) {}
-    }
 
   ReturnValue_t checkCrc() {
     uint8_t* crcPtr = this->getPacketData() + this->getPacketDataLength() - 1;
     uint16_t receivedCrc = *(crcPtr) << 8 | *(crcPtr + 1);
-        uint16_t recalculatedCrc = CRC::crc16ccitt(this->localData.byteStream, this->getFullSize());
+    uint16_t recalculatedCrc =
+        CRC::crc16ccitt(this->localData.byteStream, this->getFullSize() - CRC_SIZE);
     if (recalculatedCrc != receivedCrc) {
       return CRC_FAILURE;
     }
@@ -180,23 +181,18 @@ public:
 /**
  * @brief   This class helps to build the memory read command for the PLOC.
  */
-class TcMemRead: public TcBase {
+class TcMemRead : public TcBase {
-public:
+ public:
-
   /**
    * @brief   Constructor
    */
-    TcMemRead(uint16_t sequenceCount) :
+  TcMemRead(uint16_t sequenceCount) : TcBase(apid::TC_MEM_READ, sequenceCount) {
-            TcBase(apid::TC_MEM_READ, sequenceCount) {
     this->setPacketDataLength(PACKET_LENGTH);
   }
 
-    uint16_t getMemLen() const {
+  uint16_t getMemLen() const { return memLen; }
-        return memLen;
-    }
-
-protected:
 
+ protected:
   ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     result = lengthCheck(commandDataLen);
@@ -204,20 +200,19 @@ protected:
       return result;
     }
     std::memcpy(this->localData.fields.buffer, commandData, MEM_ADDRESS_SIZE);
-        std::memcpy(this->localData.fields.buffer + MEM_ADDRESS_SIZE,
+    std::memcpy(this->localData.fields.buffer + MEM_ADDRESS_SIZE, commandData + MEM_ADDRESS_SIZE,
-                commandData + MEM_ADDRESS_SIZE, MEM_LEN_SIZE);
+                MEM_LEN_SIZE);
     size_t size = sizeof(memLen);
     const uint8_t* memLenPtr = commandData + MEM_ADDRESS_SIZE;
-        result = SerializeAdapter::deSerialize(&memLen, &memLenPtr, &size,
+    result =
-                SerializeIF::Endianness::BIG);
+        SerializeAdapter::deSerialize(&memLen, &memLenPtr, &size, SerializeIF::Endianness::BIG);
-        if(result != HasReturnvaluesIF::RETURN_OK) {
+    if (result != HasReturnvaluesIF::RETURN_OK) {
       return result;
     }
     return result;
   }
 
-private:
+ private:
-
   static const size_t COMMAND_LENGTH = 6;
   static const size_t MEM_ADDRESS_SIZE = 4;
   static const size_t MEM_LEN_SIZE = 2;
@@ -226,7 +221,7 @@ private:
   uint16_t memLen = 0;
 
   ReturnValue_t lengthCheck(size_t commandDataLen) {
-        if (commandDataLen != COMMAND_LENGTH){
+    if (commandDataLen != COMMAND_LENGTH) {
       return INVALID_LENGTH;
     }
     return HasReturnvaluesIF::RETURN_OK;
@@ -237,16 +232,14 @@ private:
  * @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 TcBase {
-public:
+ public:
   /**
    * @brief   Constructor
    */
-    TcMemWrite(uint16_t sequenceCount) : TcBase(apid::TC_MEM_WRITE, sequenceCount) {
+  TcMemWrite(uint16_t sequenceCount) : TcBase(apid::TC_MEM_WRITE, sequenceCount) {}
-    }
-
-protected:
 
+ protected:
   ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     result = lengthCheck(commandDataLen);
@@ -254,14 +247,13 @@ protected:
       return result;
     }
     std::memcpy(this->localData.fields.buffer, commandData, commandDataLen);
-        uint16_t memLen = *(commandData + MEM_ADDRESS_SIZE) << 8
+    uint16_t memLen =
-                | *(commandData + MEM_ADDRESS_SIZE + 1);
+        *(commandData + MEM_ADDRESS_SIZE) << 8 | *(commandData + MEM_ADDRESS_SIZE + 1);
     this->setPacketDataLength(memLen * 4 + FIX_LENGTH - 1);
     return result;
   }
 
-private:
+ private:
-
   // Min length consists of 4 byte address, 2 byte mem length field, 4 byte data (1 word)
   static const size_t MIN_COMMAND_DATA_LENGTH = 10;
   static const size_t MEM_ADDRESS_SIZE = 4;
@@ -280,47 +272,47 @@ private:
  * @brief   Class to help creation of flash fopen command.
  */
 class FlashFopen : public TcBase {
-public:
+ public:
-
+  FlashFopen(uint16_t sequenceCount) : TcBase(apid::TC_FLASHFOPEN, sequenceCount) {}
-    FlashFopen(uint16_t sequenceCount) :
-            TcBase(apid::TC_FLASHFOPEN, sequenceCount) {
-    }
 
   static const char APPEND = 'a';
   static const char WRITE = 'w';
   static const char READ = 'r';
 
-    ReturnValue_t createPacket(std::string filename, char accessMode) {
+  ReturnValue_t createPacket(std::string filename, char accessMode_) {
+    accessMode = accessMode_;
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     size_t nameSize = filename.size();
-    	std::memcpy(this->getPacketData(), filename.c_str(),
+    std::memcpy(this->getPacketData(), filename.c_str(), nameSize);
-    	                nameSize);
+    *(this->getPacketData() + nameSize) = NULL_TERMINATOR;
-    	std::memcpy(this->getPacketData() + nameSize + 1, &accessMode,
+    std::memcpy(this->getPacketData() + nameSize + sizeof(NULL_TERMINATOR), &accessMode,
                 sizeof(accessMode));
-    	this->setPacketDataLength(nameSize + CRC_SIZE - 1);
+    this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + sizeof(accessMode) + CRC_SIZE -
+                              1);
     result = addCrc();
     if (result != HasReturnvaluesIF::RETURN_OK) {
       return result;
     }
     return result;
   }
+
+ private:
+  char accessMode = APPEND;
 };
 
 /**
  * @brief   Class to help creation of flash fclose command.
  */
-class FlashFclose: public TcBase {
+class FlashFclose : public TcBase {
-public:
+ public:
-
+  FlashFclose(uint16_t sequenceCount) : TcBase(apid::TC_FLASHFCLOSE, sequenceCount) {}
-	FlashFclose(uint16_t sequenceCount) :
-			TcBase(apid::TC_FLASHFCLOSE, sequenceCount) {
-	}
 
   ReturnValue_t createPacket(std::string filename) {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     size_t nameSize = filename.size();
     std::memcpy(this->getPacketData(), filename.c_str(), nameSize);
-		this->setPacketDataLength(nameSize + CRC_SIZE - 1);
+    *(this->getPacketData() + nameSize) = NULL_TERMINATOR;
+    this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1);
     result = addCrc();
     if (result != HasReturnvaluesIF::RETURN_OK) {
       return result;
@@ -333,43 +325,49 @@ public:
  * @brief   Class to build flash write space packet.
  */
 class TcFlashWrite : public TcBase {
-public:
+ public:
+  TcFlashWrite(uint16_t sequenceCount) : TcBase(apid::TC_FLASHWRITE, sequenceCount) {}
 
-    TcFlashWrite(uint16_t sequenceCount) :
+  ReturnValue_t createPacket(const uint8_t* writeData, uint32_t writeLen_) {
-            TcBase(apid::TC_FLASHWRITE, sequenceCount) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    }
+    writeLen = writeLen_;
-
-    ReturnValue_t createPacket(uint8_t* writeData, uint32_t writeLen) {
     if (writeLen > MAX_DATA_SIZE) {
       sif::debug << "FlashWrite::createPacket: Command data too big" << std::endl;
       return HasReturnvaluesIF::RETURN_FAILED;
     }
-        std::memcpy(this->getPacketData(), &writeLen, sizeof(writeLen));
+    size_t serializedSize = 0;
+    result =
+        SerializeAdapter::serialize<uint32_t>(&writeLen, this->getPacketData(), &serializedSize,
+                                              sizeof(writeLen), SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
     std::memcpy(this->getPacketData() + sizeof(writeLen), writeData, writeLen);
     this->setPacketDataLength(static_cast<uint16_t>(writeLen + CRC_SIZE - 1));
-        ReturnValue_t result = addCrc();
+    result = addCrc();
     if (result != HasReturnvaluesIF::RETURN_OK) {
       return result;
     }
     return HasReturnvaluesIF::RETURN_OK;
   }
+
+ private:
+  uint32_t writeLen = 0;
 };
 
 /**
  * @brief   Class to help creation of flash delete command.
  */
-class TcFlashDelete: public TcBase {
+class TcFlashDelete : public TcBase {
-public:
+ public:
-
+  TcFlashDelete(uint16_t sequenceCount) : TcBase(apid::TC_FLASHDELETE, sequenceCount) {}
-	TcFlashDelete(uint16_t sequenceCount) :
-			TcBase(apid::TC_FLASHDELETE , sequenceCount) {
-	}
 
   ReturnValue_t createPacket(std::string filename) {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     size_t nameSize = filename.size();
     std::memcpy(this->getPacketData(), filename.c_str(), nameSize);
-		this->setPacketDataLength(nameSize + CRC_SIZE - 1);
+    *(this->getPacketData() + nameSize) = NULL_TERMINATOR;
+    this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1);
     result = addCrc();
     if (result != HasReturnvaluesIF::RETURN_OK) {
       return result;
@@ -382,11 +380,8 @@ public:
  * @brief   Class to build replay stop space packet.
  */
 class TcReplayStop : public TcBase {
-public:
+ public:
-
+  TcReplayStop(uint16_t sequenceCount) : TcBase(apid::TC_REPLAY_STOP, sequenceCount) {}
-    TcReplayStop(uint16_t sequenceCount) :
-            TcBase(apid::TC_REPLAY_STOP, sequenceCount) {
-    }
 
   ReturnValue_t createPacket() {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
@@ -402,16 +397,14 @@ public:
 /**
  * @brief   This class helps to build the replay start command.
  */
-class TcReplayStart: public TcBase {
+class TcReplayStart : public TcBase {
-public:
+ public:
   /**
    * @brief   Constructor
    */
-	TcReplayStart(uint16_t sequenceCount) : TcBase(apid::TC_REPLAY_START, sequenceCount) {
+  TcReplayStart(uint16_t sequenceCount) : TcBase(apid::TC_REPLAY_START, sequenceCount) {}
-    }
-
-protected:
 
+ protected:
   ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     result = lengthCheck(commandDataLen);
@@ -427,8 +420,7 @@ protected:
     return result;
   }
 
-private:
+ private:
-
   static const size_t COMMAND_DATA_LENGTH = 1;
   static const uint8_t REPEATING = 0;
   static const uint8_t ONCE = 1;
@@ -453,16 +445,14 @@ private:
 /**
  * @brief   This class helps to build downlink power on command.
  */
-class TcDownlinkPwrOn: public TcBase {
+class TcDownlinkPwrOn : public TcBase {
-public:
+ public:
   /**
    * @brief   Constructor
    */
-	TcDownlinkPwrOn(uint16_t sequenceCount) : TcBase(apid::TC_DOWNLINK_PWR_ON, sequenceCount) {
+  TcDownlinkPwrOn(uint16_t sequenceCount) : TcBase(apid::TC_DOWNLINK_PWR_ON, sequenceCount) {}
-    }
-
-protected:
 
+ protected:
   ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     result = lengthCheck(commandDataLen);
@@ -484,8 +474,7 @@ protected:
     return result;
   }
 
-private:
+ private:
-
   static const uint8_t INTERFACE_ID = CLASS_ID::DWLPWRON_CMD;
 
   //! [EXPORT] : [COMMENT] Received command has invalid JESD mode (valid modes are 0 - 5)
@@ -527,11 +516,8 @@ private:
  * @brief   Class to build replay stop space packet.
  */
 class TcDownlinkPwrOff : public TcBase {
-public:
+ public:
-
+  TcDownlinkPwrOff(uint16_t sequenceCount) : TcBase(apid::TC_DOWNLINK_PWR_OFF, sequenceCount) {}
-    TcDownlinkPwrOff(uint16_t sequenceCount) :
-            TcBase(apid::TC_DOWNLINK_PWR_OFF, sequenceCount) {
-    }
 
   ReturnValue_t createPacket() {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
@@ -544,19 +530,18 @@ public:
   }
 };
 
-
 /**
  * @brief   This class helps to build the replay start command.
  */
-class TcReplayWriteSeq: public TcBase {
+class TcReplayWriteSeq : public TcBase {
-public:
+ public:
   /**
    * @brief   Constructor
    */
- TcReplayWriteSeq(uint16_t sequenceCount) : TcBase(apid::TC_REPLAY_WRITE_SEQUENCE, sequenceCount) {}
+  TcReplayWriteSeq(uint16_t sequenceCount)
-
+      : TcBase(apid::TC_REPLAY_WRITE_SEQUENCE, sequenceCount) {}
-protected:
 
+ protected:
   ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
     result = lengthCheck(commandDataLen);
@@ -564,17 +549,18 @@ protected:
       return result;
     }
     std::memcpy(this->localData.fields.buffer, commandData, commandDataLen);
-        this->setPacketDataLength(commandDataLen + CRC_SIZE - 1);
+    *(this->localData.fields.buffer + commandDataLen) = NULL_TERMINATOR;
+    this->setPacketDataLength(commandDataLen + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1);
     return result;
   }
 
-private:
+ private:
-
   static const size_t USE_DECODING_LENGTH = 1;
 
   ReturnValue_t lengthCheck(size_t commandDataLen) {
     if (commandDataLen > USE_DECODING_LENGTH + MAX_FILENAME_SIZE) {
-          sif::warning << "TcReplayWriteSeq: Command has invalid length " << commandDataLen << std::endl;
+      sif::warning << "TcReplayWriteSeq: Command has invalid length " << commandDataLen
+                   << std::endl;
       return INVALID_LENGTH;
     }
     return HasReturnvaluesIF::RETURN_OK;
@@ -601,16 +587,11 @@ class FlashWritePusCmd : public MPSoCReturnValuesIF {
     return HasReturnvaluesIF::RETURN_OK;
   }
 
-  std::string getObcFile() {
+  std::string getObcFile() { return obcFile; }
-      return obcFile;
-  }
 
-  std::string getMPSoCFile() {
+  std::string getMPSoCFile() { return mpsocFile; }
-      return mpsocFile;
-  }
 
  private:
-
   static const size_t SIZE_NULL_TERMINATOR = 1;
   std::string obcFile = "";
   std::string mpsocFile = "";
@@ -620,11 +601,8 @@ class FlashWritePusCmd : public MPSoCReturnValuesIF {
  * @brief   Class to build replay stop space packet.
  */
 class TcModeReplay : public TcBase {
-public:
+ public:
-
+  TcModeReplay(uint16_t sequenceCount) : TcBase(apid::TC_MODE_REPLAY, sequenceCount) {}
-    TcModeReplay(uint16_t sequenceCount) :
-            TcBase(apid::TC_MODE_REPLAY, sequenceCount) {
-    }
 
   ReturnValue_t createPacket() {
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
@@ -637,8 +615,6 @@ public:
   }
 };
 
-}
+}  // namespace mpsoc
-
-
 
 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ */

linux/devices/ploc/PlocMPSoCHandler.cpp

@@ -5,10 +5,13 @@
 #include "fsfw/globalfunctions/CRC.h"
 
 PlocMPSoCHandler::PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid,
-                                   CookieIF* comCookie, PlocMPSoCHelper* plocMPSoCHelper)
+                                   CookieIF* comCookie, PlocMPSoCHelper* plocMPSoCHelper,
-    : DeviceHandlerBase(objectId, uartComIFid, comCookie), plocMPSoCHelper(plocMPSoCHelper) {
+                                   Gpio uartIsolatorSwitch)
-  if (comCookie == NULL) {
+    : DeviceHandlerBase(objectId, uartComIFid, comCookie),
-    sif::error << "PlocMPSoCHandler: Invalid com cookie" << std::endl;
+      plocMPSoCHelper(plocMPSoCHelper),
+      uartIsolatorSwitch(uartIsolatorSwitch) {
+  if (comCookie == nullptr) {
+    sif::error << "PlocMPSoCHandler: Invalid communication cookie" << std::endl;
   }
   eventQueue = QueueFactory::instance()->createMessageQueue(EventMessage::EVENT_MESSAGE_SIZE * 5);
 }
@@ -100,7 +103,11 @@ ReturnValue_t PlocMPSoCHandler::executeAction(ActionId_t actionId, MessageQueueI
         return result;
       }
       plocMPSoCHelperExecuting = true;
-      break;
+      return EXECUTION_FINISHED;
+    }
+    case (mpsoc::OBSW_RESET_SEQ_COUNT): {
+      sequenceCount = 0;
+      return EXECUTION_FINISHED;
     }
     default:
       break;
@@ -114,9 +121,13 @@ void PlocMPSoCHandler::doStartUp() {
 #else
   setMode(_MODE_TO_ON);
 #endif
+  uartIsolatorSwitch.pullHigh();
 }
 
-void PlocMPSoCHandler::doShutDown() { setMode(_MODE_POWER_DOWN); }
+void PlocMPSoCHandler::doShutDown() {
+  uartIsolatorSwitch.pullLow();
+  setMode(_MODE_POWER_DOWN);
+}
 
 ReturnValue_t PlocMPSoCHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
   return NOTHING_TO_SEND;
@@ -167,10 +178,6 @@ ReturnValue_t PlocMPSoCHandler::buildCommandFromCommand(DeviceCommandId_t device
       result = prepareTcModeReplay();
       break;
     }
-    case (mpsoc::OBSW_RESET_SEQ_COUNT): {
-      sequenceCount = 0;
-      break;
-    }
     default:
       sif::debug << "PlocMPSoCHandler::buildCommandFromCommand: Command not implemented"
                  << std::endl;
@@ -198,7 +205,6 @@ void PlocMPSoCHandler::fillCommandAndReplyMap() {
   this->insertInCommandMap(mpsoc::TC_DOWNLINK_PWR_OFF);
   this->insertInCommandMap(mpsoc::TC_REPLAY_WRITE_SEQUENCE);
   this->insertInCommandMap(mpsoc::TC_MODE_REPLAY);
-  this->insertInCommandMap(mpsoc::OBSW_RESET_SEQ_COUNT);
   this->insertInReplyMap(mpsoc::ACK_REPORT, 1, nullptr, mpsoc::SIZE_ACK_REPORT);
   this->insertInReplyMap(mpsoc::EXE_REPORT, 3, nullptr, mpsoc::SIZE_EXE_REPORT);
   this->insertInReplyMap(mpsoc::TM_MEMORY_READ_REPORT, 2, nullptr, mpsoc::SIZE_TM_MEM_READ_REPORT);
@@ -603,13 +609,15 @@ ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator
   switch (command->first) {
     case mpsoc::TC_REPLAY_WRITE_SEQUENCE: {
       DeviceReplyIter iter = deviceReplyMap.find(mpsoc::EXE_REPORT);
-      if (iter != deviceReplyMap.end()) {
       // Overwrite delay cycles because replay write sequence command can required up to
       // 30 seconds for execution
       iter->second.delayCycles = mpsoc::TC_WRITE_SEQ_EXECUTION_DELAY;
-      } else {
+      break;
-        sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Unknown reply id" << std::endl;
     }
+    case mpsoc::TC_DOWNLINK_PWR_ON: {
+      DeviceReplyIter iter = deviceReplyMap.find(mpsoc::EXE_REPORT);
+      //
+      iter->second.delayCycles = mpsoc::TC_DOWNLINK_PWR_ON;
       break;
     }
     default:
@@ -719,6 +727,7 @@ void PlocMPSoCHandler::disableAllReplies() {
 
   /* We must always disable the execution report reply here */
   disableExeReportReply();
+  nextReplyId = mpsoc::NONE;
 }
 
 void PlocMPSoCHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status) {
@@ -743,7 +752,7 @@ void PlocMPSoCHandler::disableExeReportReply() {
   DeviceReplyInfo* info = &(iter->second);
   info->delayCycles = 0;
   info->command = deviceCommandMap.end();
-  /* Expected replies is set to one here. The value will set to 0 in replyToReply() */
+  /* Expected replies is set to one here. The value will be set to 0 in replyToReply() */
   info->command->second.expectedReplies = 0;
 }
 

linux/devices/ploc/PlocMPSoCHandler.h

@@ -2,50 +2,51 @@
 #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 "fsfw_hal/linux/gpio/Gpio.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
+ * @details The PLOC uses the space packet protocol for communication. Each command will be
- *          answers with at least one acknowledgment and one execution report.
+ *          answered 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.
+ *       packet otherwise the MPSoC will reply with an acknowledgment failure report.
  *
  * @author	J. Meier
  */
-class PlocMPSoCHandler: public DeviceHandlerBase {
+class PlocMPSoCHandler : public DeviceHandlerBase {
-public:
+ public:
-
+  PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie,
-    PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF * comCookie,
+                   PlocMPSoCHelper* plocMPSoCHelper, Gpio uartIsolatorSwitch);
-            PlocMPSoCHelper* plocMPSoCHelper);
   virtual ~PlocMPSoCHandler();
   virtual ReturnValue_t initialize() override;
   ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                               const uint8_t* data, size_t size) override;
   void performOperationHook() override;
 
-protected:
+ protected:
   void doStartUp() override;
   void doShutDown() override;
-	ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
-	ReturnValue_t buildTransitionDeviceCommand(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,
@@ -55,8 +56,7 @@ protected:
                                       DeviceCommandId_t alternateReplyID = 0) override;
   size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
 
-private:
+ private:
-
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HANDLER;
 
   //! [EXPORT] : [COMMENT] PLOC crc failure in telemetry packet
@@ -71,9 +71,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
@@ -99,6 +98,7 @@ private:
   UartComIF* uartComIf = nullptr;
 
   PlocMPSoCHelper* plocMPSoCHelper = nullptr;
+  Gpio uartIsolatorSwitch;
 
   // Used to block incoming commands when MPSoC helper class is currently executing a command
   bool plocMPSoCHelperExecuting = false;
@@ -116,14 +116,14 @@ private:
    */
   void handleEvent(EventMessage* eventMessage);
 
-    ReturnValue_t prepareTcMemWrite(const uint8_t * commandData, size_t commandDataLen);
+  ReturnValue_t prepareTcMemWrite(const uint8_t* commandData, size_t commandDataLen);
-    ReturnValue_t prepareTcMemRead(const uint8_t * commandData, size_t commandDataLen);
+  ReturnValue_t prepareTcMemRead(const uint8_t* commandData, size_t commandDataLen);
-    ReturnValue_t prepareTcFlashDelete(const uint8_t * commandData, size_t commandDataLen);
+  ReturnValue_t prepareTcFlashDelete(const uint8_t* commandData, size_t commandDataLen);
-    ReturnValue_t prepareTcReplayStart(const uint8_t * commandData, size_t commandDataLen);
+  ReturnValue_t prepareTcReplayStart(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcReplayStop();
-    ReturnValue_t prepareTcDownlinkPwrOn(const uint8_t * commandData, size_t commandDataLen);
+  ReturnValue_t prepareTcDownlinkPwrOn(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcDownlinkPwrOff();
-    ReturnValue_t prepareTcReplayWriteSequence(const uint8_t * commandData, size_t commandDataLen);
+  ReturnValue_t prepareTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen);
 
   /**
    * @brief   Copies space packet into command buffer

linux/devices/ploc/PlocMPSoCHelper.cpp

@@ -67,8 +67,9 @@ void PlocMPSoCHelper::setSequenceCount(SourceSequenceCounter* sequenceCount_) {
 }
 
 ReturnValue_t PlocMPSoCHelper::startFlashWrite(std::string obcFile, std::string mpsocFile) {
+  ReturnValue_t result = RETURN_OK;
 #ifdef XIPHOS_Q7S
-  ReturnValue_t result = FilesystemHelper::checkPath(obcFile);
+  result = FilesystemHelper::checkPath(obcFile);
   if (result != RETURN_OK) {
     return result;
   }
@@ -88,9 +89,19 @@ ReturnValue_t PlocMPSoCHelper::startFlashWrite(std::string obcFile, std::string
   flashWrite.obcFile = obcFile;
   flashWrite.mpsocFile = mpsocFile;
   internalState = InternalState::FLASH_WRITE;
+  result = resetHelper();
+  if (result != RETURN_OK) {
+    return result;
+  }
+  return result;
+}
+
+ReturnValue_t PlocMPSoCHelper::resetHelper() {
+  ReturnValue_t result = RETURN_OK;
   semaphore.release();
   terminate = false;
-  return RETURN_OK;
+  result = uartComIF->flushUartRxBuffer(comCookie);
+  return result;
 }
 
 void PlocMPSoCHelper::stopProcess() { terminate = true; }
@@ -108,6 +119,7 @@ ReturnValue_t PlocMPSoCHelper::performFlashWrite() {
   // 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 RETURN_OK;
@@ -117,19 +129,18 @@ ReturnValue_t PlocMPSoCHelper::performFlashWrite() {
     } else {
       dataLength = remainingSize;
     }
+    if (file.is_open()) {
+      file.seekg(bytesRead, file.beg);
       file.read(reinterpret_cast<char*>(tempData), dataLength);
+      bytesRead += dataLength;
+      remainingSize -= dataLength;
+    } else {
+      return FILE_CLOSED_ACCIDENTALLY;
+    }
     (*sequenceCount)++;
     mpsoc::TcFlashWrite tc(*sequenceCount);
     tc.createPacket(tempData, dataLength);
-    result = sendCommand(&tc);
+    result = handlePacketTransmission(tc);
-    if (result != RETURN_OK) {
-      return result;
-    }
-    result = handleAck();
-    if (result != RETURN_OK) {
-      return result;
-    }
-    result = handleExe();
     if (result != RETURN_OK) {
       return result;
     }
@@ -149,7 +160,7 @@ ReturnValue_t PlocMPSoCHelper::flashfopen() {
   if (result != RETURN_OK) {
     return result;
   }
-  result = sendCommand(&flashFopen);
+  result = handlePacketTransmission(flashFopen);
   if (result != RETURN_OK) {
     return result;
   }
@@ -164,16 +175,33 @@ ReturnValue_t PlocMPSoCHelper::flashfclose() {
   if (result != RETURN_OK) {
     return result;
   }
-	result = sendCommand(&flashFclose);
+  result = handlePacketTransmission(flashFclose);
   if (result != RETURN_OK) {
     return result;
   }
   return RETURN_OK;
 }
 
-ReturnValue_t PlocMPSoCHelper::sendCommand(mpsoc::TcBase* tc) {
+ReturnValue_t PlocMPSoCHelper::handlePacketTransmission(mpsoc::TcBase& tc) {
   ReturnValue_t result = RETURN_OK;
-  result = uartComIF->sendMessage(comCookie, tc->getWholeData(), tc->getFullSize());
+  result = sendCommand(tc);
+  if (result != RETURN_OK) {
+    return result;
+  }
+  result = handleAck();
+  if (result != RETURN_OK) {
+    return result;
+  }
+  result = handleExe();
+  if (result != RETURN_OK) {
+    return result;
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHelper::sendCommand(mpsoc::TcBase& tc) {
+  ReturnValue_t result = RETURN_OK;
+  result = uartComIF->sendMessage(comCookie, tc.getWholeData(), tc.getFullSize());
   if (result != RETURN_OK) {
     sif::warning << "PlocMPSoCHelper::sendCommand: Failed to send command" << std::endl;
     triggerEvent(SENDING_COMMAND_FAILED, result, static_cast<uint32_t>(internalState));
@@ -231,7 +259,7 @@ void PlocMPSoCHelper::handleExeApidFailure(uint16_t apid) {
                  << "report" << std::endl;
   } else {
     triggerEvent(EXE_INVALID_APID, apid, static_cast<uint32_t>(internalState));
-    sif::warning << "PlocMPSoCHelper::handleAckApidFailure: Expected execution report "
+    sif::warning << "PlocMPSoCHelper::handleExeApidFailure: Expected execution report "
                  << "but received space packet with apid " << std::hex << apid << std::endl;
   }
 }
@@ -239,12 +267,14 @@ void PlocMPSoCHelper::handleExeApidFailure(uint16_t apid) {
 ReturnValue_t PlocMPSoCHelper::handleTmReception(mpsoc::TmPacket* tmPacket, size_t remainingBytes) {
   ReturnValue_t result = RETURN_OK;
   size_t readBytes = 0;
+  size_t currentBytes = 0;
   for (int retries = 0; retries < RETRIES; retries++) {
-    result = receive(tmPacket->getWholeData(), &readBytes, remainingBytes);
+    result = receive(tmPacket->getWholeData() + readBytes, &currentBytes, remainingBytes);
     if (result != RETURN_OK) {
       return result;
     }
-    remainingBytes = remainingBytes - readBytes;
+    readBytes += currentBytes;
+    remainingBytes = remainingBytes - currentBytes;
     if (remainingBytes == 0) {
       break;
     }
@@ -259,17 +289,18 @@ ReturnValue_t PlocMPSoCHelper::handleTmReception(mpsoc::TmPacket* tmPacket, size
     sif::warning << "PlocMPSoCHelper::handleTmReception: CRC check failed" << std::endl;
     return result;
   }
+  (*sequenceCount)++;
   uint16_t recvSeqCnt = tmPacket->getPacketSequenceCount();
   if (recvSeqCnt != *sequenceCount) {
     triggerEvent(MPSOC_HELPER_SEQ_CNT_MISMATCH, *sequenceCount, recvSeqCnt);
     *sequenceCount = recvSeqCnt;
-    return result;
   }
   return result;
 }
 
 ReturnValue_t PlocMPSoCHelper::receive(uint8_t* data, size_t* readBytes, size_t requestBytes) {
   ReturnValue_t result = RETURN_OK;
+  uint8_t* buffer = nullptr;
   result = uartComIF->requestReceiveMessage(comCookie, requestBytes);
   if (result != RETURN_OK) {
     sif::warning << "PlocMPSoCHelper::receive: Failed to request reply" << std::endl;
@@ -277,11 +308,14 @@ ReturnValue_t PlocMPSoCHelper::receive(uint8_t* data, size_t* readBytes, size_t
                  static_cast<uint32_t>(static_cast<uint32_t>(internalState)));
     return RETURN_FAILED;
   }
-  result = uartComIF->readReceivedMessage(comCookie, &data, readBytes);
+  result = uartComIF->readReceivedMessage(comCookie, &buffer, readBytes);
   if (result != RETURN_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 RETURN_FAILED;
   }
+  if (*readBytes > 0) {
+    std::memcpy(data, buffer, *readBytes);
+  }
   return result;
 }

linux/devices/ploc/PlocMPSoCHelper.h

@@ -2,13 +2,14 @@
 #define BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_
 
 #include <string>
+
+#include "fsfw/devicehandlers/CookieIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/osal/linux/BinarySemaphore.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
-#include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
-#include "fsfw_hal/linux/uart/UartComIF.h"
-#include "fsfw/devicehandlers/CookieIF.h"
 #include "fsfw/tmtcservices/SourceSequenceCounter.h"
+#include "fsfw_hal/linux/uart/UartComIF.h"
 #include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/memory/SdCardManager.h"
@@ -19,52 +20,52 @@
  *          MPSoC and OBC.
  * @author  J. Meier
  */
-class PlocMPSoCHelper: public SystemObject, public ExecutableObjectIF, public HasReturnvaluesIF {
+class PlocMPSoCHelper : public SystemObject, public ExecutableObjectIF, public HasReturnvaluesIF {
-public:
+ 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::LOW);
-    //! [EXPORT] : [COMMENT] Communication interface returned failure when trying to send the command ot the PLOC
+  //! [EXPORT] : [COMMENT] Communication interface returned failure when trying to send the command
-    //!P1: Return value returned by the communication interface sendMessage function
+  //! ot the PLOC
-    //!P2: Internal state of MPSoC helper
+  //! P1: Return value returned by the communication interface sendMessage function
+  //! P2: Internal state of MPSoC helper
   static const Event 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
+  //! P1: Return value returned by the communication interface requestReceiveMessage function
-    //!P2: Internal state of MPSoC helper
+  //! 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
+  //! P1: Return value returned by the communication interface readingReceivedMessage function
-    //!P2: Internal state of MPSoC helper
+  //! P2: Internal state of MPSoC helper
   static const Event MPSOC_HELPER_READING_REPLY_FAILED = MAKE_EVENT(4, severity::LOW);
   //! [EXPORT] : [COMMENT] Did not receive acknowledgement report
-    //!P1: Number of bytes missing
+  //! P1: Number of bytes missing
-    //!P2: Internal state of MPSoC helper
+  //! P2: Internal state of MPSoC helper
   static const Event MISSING_ACK = MAKE_EVENT(5, severity::LOW);
   //! [EXPORT] : [COMMENT] Did not receive execution report
-    //!P1: Number of bytes missing
+  //! P1: Number of bytes missing
-    //!P2: Internal state of MPSoC helper
+  //! P2: Internal state of MPSoC helper
   static const Event MISSING_EXE = MAKE_EVENT(6, severity::LOW);
   //! [EXPORT] : [COMMENT] Received acknowledgement failure report
-    //!P1: Internal state of MPSoC
+  //! P1: Internal state of MPSoC
   static const Event ACK_FAILURE_REPORT = MAKE_EVENT(7, severity::LOW);
   //! [EXPORT] : [COMMENT] Received execution failure report
-    //!P1: Internal state of MPSoC
+  //! P1: Internal state of MPSoC
   static const Event EXE_FAILURE_REPORT = MAKE_EVENT(8, severity::LOW);
   //! [EXPORT] : [COMMENT] Expected acknowledgement report but received space packet with other apid
-    //!P1: Apid of received space packet
+  //! P1: Apid of received space packet
-    //!P2: Internal state of MPSoC
+  //! P2: Internal state of MPSoC
   static const Event 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
+  //! P1: Apid of received space packet
-    //!P2: Internal state of MPSoC
+  //! P2: Internal state of MPSoC
   static const Event EXE_INVALID_APID = MAKE_EVENT(10, severity::LOW);
   //! [EXPORT] : [COMMENT] Received sequence count does not match expected sequence count
-    //!P1: Expected sequence count
+  //! P1: Expected sequence count
-    //!P2: Received sequence count
+  //! P2: Received sequence count
   static const Event MPSOC_HELPER_SEQ_CNT_MISMATCH = MAKE_EVENT(11, severity::LOW);
 
   PlocMPSoCHelper(object_id_t objectId);
@@ -96,13 +97,15 @@ public:
    */
   void setSequenceCount(SourceSequenceCounter* sequenceCount_);
 
-private:
+ private:
-
   static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MPSOC_HELPER;
 
+  //! [EXPORT] : [COMMENT] File accidentally close
+  static const ReturnValue_t FILE_CLOSED_ACCIDENTALLY = MAKE_RETURN_CODE(0xA0);
+
   // Maximum number of times the communication interface retries polling data from the reply
   // buffer
-    static const int RETRIES = 3;
+  static const int RETRIES = 10000;
 
   struct FlashWrite {
     std::string obcFile;
@@ -111,11 +114,7 @@ private:
 
   struct FlashWrite flashWrite;
 
-    enum class InternalState {
+  enum class InternalState { IDLE, FLASH_WRITE, FLASH_READ };
-        IDLE,
-        FLASH_WRITE,
-        FLASH_READ
-    };
 
   InternalState internalState = InternalState::IDLE;
 
@@ -137,10 +136,12 @@ private:
   // Sequence count, must be set by Ploc MPSoC Handler
   SourceSequenceCounter* sequenceCount;
 
+  ReturnValue_t resetHelper();
   ReturnValue_t performFlashWrite();
   ReturnValue_t flashfopen();
   ReturnValue_t flashfclose();
-    ReturnValue_t sendCommand(mpsoc::TcBase* tc);
+  ReturnValue_t handlePacketTransmission(mpsoc::TcBase& tc);
+  ReturnValue_t sendCommand(mpsoc::TcBase& tc);
   ReturnValue_t receive(uint8_t* data, size_t* readBytes, size_t requestBytes);
   ReturnValue_t handleAck();
   ReturnValue_t handleExe();

linux/devices/ploc/PlocSupervisorHandler.cpp

@@ -1,24 +1,30 @@
-#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(
+                                             Gpio uartIsolatorSwitch)
-                this) {
+    : DeviceHandlerBase(objectId, uartComIFid, comCookie),
+      uartIsolatorSwitch(uartIsolatorSwitch),
+      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;
@@ -31,225 +37,224 @@ ReturnValue_t PlocSupervisorHandler::initialize() {
     sif::warning << "PlocSupervisorHandler::initialize: Invalid uart com if" << std::endl;
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
-#if BOARD_TE0720 == 0
+#ifdef TE0720_1CFA
   sdcMan = SdCardManager::instance();
 #endif /* BOARD_TE0720 == 0 */
   return result;
 }
 
-
+void PlocSupervisorHandler::doStartUp() {
-void PlocSupervisorHandler::doStartUp(){
 #if OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP == 1
   setMode(MODE_NORMAL);
 #else
   setMode(_MODE_TO_ON);
 #endif
+  uartIsolatorSwitch.pullHigh();
 }
 
-void PlocSupervisorHandler::doShutDown(){
+void PlocSupervisorHandler::doShutDown() {
     setMode(_MODE_POWER_DOWN);
+    uartIsolatorSwitch.pullLow();
 }
 
-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) {
+  switch (deviceCommand) {
-	case(PLOC_SPV::GET_HK_REPORT): {
+    case (PLOC_SPV::GET_HK_REPORT): {
       prepareEmptyCmd(PLOC_SPV::APID_GET_HK_REPORT);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::RESTART_MPSOC): {
+    case (PLOC_SPV::RESTART_MPSOC): {
       prepareEmptyCmd(PLOC_SPV::APID_RESTART_MPSOC);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::START_MPSOC): {
+    case (PLOC_SPV::START_MPSOC): {
       prepareEmptyCmd(PLOC_SPV::APID_START_MPSOC);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::SHUTDOWN_MPSOC): {
+    case (PLOC_SPV::SHUTDOWN_MPSOC): {
       prepareEmptyCmd(PLOC_SPV::APID_SHUTWOWN_MPSOC);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::SEL_MPSOC_BOOT_IMAGE): {
+    case (PLOC_SPV::SEL_MPSOC_BOOT_IMAGE): {
       prepareSelBootImageCmd(commandData);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::RESET_MPSOC): {
+    case (PLOC_SPV::RESET_MPSOC): {
       prepareEmptyCmd(PLOC_SPV::APID_RESET_MPSOC);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::SET_TIME_REF): {
+    case (PLOC_SPV::SET_TIME_REF): {
       result = prepareSetTimeRefCmd();
       break;
     }
-	case(PLOC_SPV::SET_BOOT_TIMEOUT): {
+    case (PLOC_SPV::SET_BOOT_TIMEOUT): {
       prepareSetBootTimeoutCmd(commandData);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::SET_MAX_RESTART_TRIES): {
+    case (PLOC_SPV::SET_MAX_RESTART_TRIES): {
       prepareRestartTriesCmd(commandData);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::DISABLE_PERIOIC_HK_TRANSMISSION): {
+    case (PLOC_SPV::DISABLE_PERIOIC_HK_TRANSMISSION): {
       prepareDisableHk();
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::GET_BOOT_STATUS_REPORT): {
+    case (PLOC_SPV::GET_BOOT_STATUS_REPORT): {
       prepareEmptyCmd(PLOC_SPV::APID_GET_BOOT_STATUS_RPT);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::WATCHDOGS_ENABLE): {
+    case (PLOC_SPV::WATCHDOGS_ENABLE): {
       prepareWatchdogsEnableCmd(commandData);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::WATCHDOGS_CONFIG_TIMEOUT): {
+    case (PLOC_SPV::WATCHDOGS_CONFIG_TIMEOUT): {
       result = prepareWatchdogsConfigTimeoutCmd(commandData);
       break;
     }
-	case(PLOC_SPV::ENABLE_LATCHUP_ALERT): {
+    case (PLOC_SPV::ENABLE_LATCHUP_ALERT): {
       result = prepareLatchupConfigCmd(commandData, deviceCommand);
       break;
     }
-	case(PLOC_SPV::DISABLE_LATCHUP_ALERT): {
+    case (PLOC_SPV::DISABLE_LATCHUP_ALERT): {
       result = prepareLatchupConfigCmd(commandData, deviceCommand);
       break;
     }
-	case(PLOC_SPV::AUTO_CALIBRATE_ALERT): {
+    case (PLOC_SPV::AUTO_CALIBRATE_ALERT): {
       result = prepareAutoCalibrateAlertCmd(commandData);
       break;
     }
-	case(PLOC_SPV::SET_ALERT_LIMIT): {
+    case (PLOC_SPV::SET_ALERT_LIMIT): {
       result = prepareSetAlertLimitCmd(commandData);
       break;
     }
-	case(PLOC_SPV::SET_ALERT_IRQ_FILTER): {
+    case (PLOC_SPV::SET_ALERT_IRQ_FILTER): {
       result = prepareSetAlertIrqFilterCmd(commandData);
       break;
     }
-	case(PLOC_SPV::SET_ADC_SWEEP_PERIOD): {
+    case (PLOC_SPV::SET_ADC_SWEEP_PERIOD): {
       result = prepareSetAdcSweetPeriodCmd(commandData);
       break;
     }
-	case(PLOC_SPV::SET_ADC_ENABLED_CHANNELS): {
+    case (PLOC_SPV::SET_ADC_ENABLED_CHANNELS): {
       prepareSetAdcEnabledChannelsCmd(commandData);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::SET_ADC_WINDOW_AND_STRIDE): {
+    case (PLOC_SPV::SET_ADC_WINDOW_AND_STRIDE): {
       prepareSetAdcWindowAndStrideCmd(commandData);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::SET_ADC_THRESHOLD): {
+    case (PLOC_SPV::SET_ADC_THRESHOLD): {
       prepareSetAdcThresholdCmd(commandData);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::GET_LATCHUP_STATUS_REPORT): {
+    case (PLOC_SPV::GET_LATCHUP_STATUS_REPORT): {
       prepareEmptyCmd(PLOC_SPV::APID_GET_LATCHUP_STATUS_REPORT);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::COPY_ADC_DATA_TO_MRAM): {
+    case (PLOC_SPV::COPY_ADC_DATA_TO_MRAM): {
       prepareEmptyCmd(PLOC_SPV::APID_COPY_ADC_DATA_TO_MRAM);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::ENABLE_NVMS): {
+    case (PLOC_SPV::ENABLE_NVMS): {
       prepareEnableNvmsCmd(commandData);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::SELECT_NVM): {
+    case (PLOC_SPV::SELECT_NVM): {
       prepareSelectNvmCmd(commandData);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::RUN_AUTO_EM_TESTS): {
+    case (PLOC_SPV::RUN_AUTO_EM_TESTS): {
       result = prepareRunAutoEmTest(commandData);
       break;
     }
-	case(PLOC_SPV::WIPE_MRAM): {
+    case (PLOC_SPV::WIPE_MRAM): {
       result = prepareWipeMramCmd(commandData);
       break;
     }
-	case(PLOC_SPV::FIRST_MRAM_DUMP):
+    case (PLOC_SPV::FIRST_MRAM_DUMP):
-	case(PLOC_SPV::CONSECUTIVE_MRAM_DUMP):
+    case (PLOC_SPV::CONSECUTIVE_MRAM_DUMP):
       result = prepareDumpMramCmd(commandData);
       break;
-	case(PLOC_SPV::PRINT_CPU_STATS): {
+    case (PLOC_SPV::PRINT_CPU_STATS): {
       preparePrintCpuStatsCmd(commandData);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::SET_DBG_VERBOSITY): {
+    case (PLOC_SPV::SET_DBG_VERBOSITY): {
       prepareSetDbgVerbosityCmd(commandData);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::CAN_LOOPBACK_TEST): {
+    case (PLOC_SPV::CAN_LOOPBACK_TEST): {
       prepareEmptyCmd(PLOC_SPV::APID_CAN_LOOPBACK_TEST);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::SET_GPIO): {
+    case (PLOC_SPV::SET_GPIO): {
       prepareSetGpioCmd(commandData);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::READ_GPIO): {
+    case (PLOC_SPV::READ_GPIO): {
       prepareReadGpioCmd(commandData);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::RESTART_SUPERVISOR): {
+    case (PLOC_SPV::RESTART_SUPERVISOR): {
       prepareEmptyCmd(PLOC_SPV::APID_RESTART_SUPERVISOR);
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::FACTORY_RESET_CLEAR_ALL): {
+    case (PLOC_SPV::FACTORY_RESET_CLEAR_ALL): {
       PLOC_SPV::FactoryReset packet(PLOC_SPV::FactoryReset::Op::CLEAR_ALL);
       packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::FACTORY_RESET_CLEAR_MIRROR): {
+    case (PLOC_SPV::FACTORY_RESET_CLEAR_MIRROR): {
       PLOC_SPV::FactoryReset packet(PLOC_SPV::FactoryReset::Op::MIRROR_ENTRIES);
       packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::FACTORY_RESET_CLEAR_CIRCULAR): {
+    case (PLOC_SPV::FACTORY_RESET_CLEAR_CIRCULAR): {
       PLOC_SPV::FactoryReset packet(PLOC_SPV::FactoryReset::Op::CIRCULAR_ENTRIES);
       packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
       result = RETURN_OK;
       break;
     }
-	case(PLOC_SPV::UPDATE_AVAILABLE):
+    case (PLOC_SPV::UPDATE_AVAILABLE):
-	case(PLOC_SPV::UPDATE_IMAGE_DATA):
+    case (PLOC_SPV::UPDATE_IMAGE_DATA):
-	case(PLOC_SPV::UPDATE_VERIFY):
+    case (PLOC_SPV::UPDATE_VERIFY):
       // Simply forward data from PLOC Updater to supervisor
       std::memcpy(commandBuffer, commandData, commandDataLen);
       rawPacket = commandBuffer;
@@ -326,14 +331,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);
   }
@@ -342,32 +345,32 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t *start,
 
   uint16_t apid = (*(start) << 8 | *(start + 1)) & APID_MASK;
 
-	switch(apid) {
+  switch (apid) {
-	case(PLOC_SPV::APID_ACK_SUCCESS):
+    case (PLOC_SPV::APID_ACK_SUCCESS):
       *foundLen = PLOC_SPV::SIZE_ACK_REPORT;
       *foundId = PLOC_SPV::ACK_REPORT;
       break;
-	case(PLOC_SPV::APID_ACK_FAILURE):
+    case (PLOC_SPV::APID_ACK_FAILURE):
       *foundLen = PLOC_SPV::SIZE_ACK_REPORT;
       *foundId = PLOC_SPV::ACK_REPORT;
       break;
-	case(PLOC_SPV::APID_HK_REPORT):
+    case (PLOC_SPV::APID_HK_REPORT):
       *foundLen = PLOC_SPV::SIZE_HK_REPORT;
       *foundId = PLOC_SPV::HK_REPORT;
       break;
-	case(PLOC_SPV::APID_BOOT_STATUS_REPORT):
+    case (PLOC_SPV::APID_BOOT_STATUS_REPORT):
       *foundLen = PLOC_SPV::SIZE_BOOT_STATUS_REPORT;
       *foundId = PLOC_SPV::BOOT_STATUS_REPORT;
       break;
-	case(PLOC_SPV::APID_LATCHUP_STATUS_REPORT):
+    case (PLOC_SPV::APID_LATCHUP_STATUS_REPORT):
       *foundLen = PLOC_SPV::SIZE_LATCHUP_STATUS_REPORT;
       *foundId = PLOC_SPV::LATCHUP_REPORT;
       break;
-	case(PLOC_SPV::APID_EXE_SUCCESS):
+    case (PLOC_SPV::APID_EXE_SUCCESS):
       *foundLen = PLOC_SPV::SIZE_EXE_REPORT;
       *foundId = PLOC_SPV::EXE_REPORT;
       break;
-	case(PLOC_SPV::APID_EXE_FAILURE):
+    case (PLOC_SPV::APID_EXE_FAILURE):
       *foundLen = PLOC_SPV::SIZE_EXE_REPORT;
       *foundId = PLOC_SPV::EXE_REPORT;
       break;
@@ -382,8 +385,7 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t *start,
 }
 
 ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
-        const uint8_t *packet) {
+                                                          const uint8_t* packet) {
-
   ReturnValue_t result = RETURN_OK;
 
   switch (id) {
@@ -412,7 +414,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,63 +423,58 @@ 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}));
+  localDataPoolMap.emplace(PLOC_SPV::SOC_STATE, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(PLOC_SPV::NVM0_1_STATE, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(PLOC_SPV::NVM3_STATE, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(PLOC_SPV::MISSION_IO_STATE, new PoolEntry<uint8_t>({0}));
+  localDataPoolMap.emplace(PLOC_SPV::FMC_STATE, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(PLOC_SPV::NUM_TCS, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(PLOC_SPV::UPTIME, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(PLOC_SPV::CPULOAD, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(PLOC_SPV::AVAILABLEHEAP, new PoolEntry<uint32_t>({0}));
 
-    localDataPoolMap.emplace(PLOC_SPV::NUM_TMS, new PoolEntry<uint32_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::BOOT_SIGNAL, new PoolEntry<uint8_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::TEMP_PS, new PoolEntry<uint32_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::RESET_COUNTER, new PoolEntry<uint8_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::TEMP_PL, new PoolEntry<uint32_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::BOOT_AFTER_MS, new PoolEntry<uint32_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::SOC_STATE, new PoolEntry<uint32_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::BOOT_TIMEOUT_MS, new PoolEntry<uint32_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::NVM0_1_STATE, new PoolEntry<uint8_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::ACTIVE_NVM, new PoolEntry<uint8_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::NVM3_STATE, new PoolEntry<uint8_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::BP0_STATE, new PoolEntry<uint8_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::MISSION_IO_STATE, new PoolEntry<uint8_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::BP1_STATE, new PoolEntry<uint8_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::FMC_STATE, new PoolEntry<uint32_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::BP2_STATE, new PoolEntry<uint8_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::NUM_TCS, new PoolEntry<uint32_t>( { 0 }));
-    localDataPoolMap.emplace(PLOC_SPV::UPTIME, new PoolEntry<uint32_t>( { 0 }));
-    localDataPoolMap.emplace(PLOC_SPV::CPULOAD, new PoolEntry<uint32_t>( { 0 }));
-    localDataPoolMap.emplace(PLOC_SPV::AVAILABLEHEAP, new PoolEntry<uint32_t>( { 0 }));
 
-    localDataPoolMap.emplace(PLOC_SPV::BOOT_SIGNAL, new PoolEntry<uint8_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::LATCHUP_ID, new PoolEntry<uint8_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::RESET_COUNTER, new PoolEntry<uint8_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::CNT0, new PoolEntry<uint16_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::BOOT_AFTER_MS, new PoolEntry<uint32_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::CNT1, new PoolEntry<uint16_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::BOOT_TIMEOUT_MS, new PoolEntry<uint32_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::CNT2, new PoolEntry<uint16_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::ACTIVE_NVM, new PoolEntry<uint8_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::CNT3, new PoolEntry<uint16_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::BP0_STATE, new PoolEntry<uint8_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::CNT4, new PoolEntry<uint16_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::BP1_STATE, new PoolEntry<uint8_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::CNT5, new PoolEntry<uint16_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::BP2_STATE, new PoolEntry<uint8_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::CNT6, new PoolEntry<uint16_t>({0}));
-
+  localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_SEC, new PoolEntry<uint32_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::LATCHUP_ID, new PoolEntry<uint8_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_MIN, new PoolEntry<uint32_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::CNT0, new PoolEntry<uint16_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_HOUR, new PoolEntry<uint32_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::CNT1, new PoolEntry<uint16_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_DAY, new PoolEntry<uint32_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::CNT2, new PoolEntry<uint16_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_MON, new PoolEntry<uint32_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::CNT3, new PoolEntry<uint16_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_YEAR, new PoolEntry<uint32_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::CNT4, new PoolEntry<uint16_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_MSEC, new PoolEntry<uint32_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::CNT5, new PoolEntry<uint16_t>( { 0 }));
+  localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_IS_SET, new PoolEntry<uint32_t>({0}));
-    localDataPoolMap.emplace(PLOC_SPV::CNT6, new PoolEntry<uint16_t>( { 0 }));
-    localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_SEC, new PoolEntry<uint32_t>( { 0 }));
-    localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_MIN, new PoolEntry<uint32_t>( { 0 }));
-    localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_HOUR, new PoolEntry<uint32_t>( { 0 }));
-    localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_DAY, new PoolEntry<uint32_t>( { 0 }));
-    localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_MON, new PoolEntry<uint32_t>( { 0 }));
-    localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_YEAR, new PoolEntry<uint32_t>( { 0 }));
-    localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_MSEC, new PoolEntry<uint32_t>( { 0 }));
-    localDataPoolMap.emplace(PLOC_SPV::LATCHUP_RPT_TIME_IS_SET, new PoolEntry<uint32_t>( { 0 }));
 
   return HasReturnvaluesIF::RETURN_OK;
 }
 
 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 +579,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,11 +606,10 @@ 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);
-    if(result == CRC_FAILURE) {
+  if (result == CRC_FAILURE) {
     sif::error << "PlocSupervisorHandler::handleAckReport: CRC failure" << std::endl;
     nextReplyId = PLOC_SPV::NONE;
     replyRawReplyIfnotWiretapped(data, PLOC_SPV::SIZE_ACK_REPORT);
@@ -624,10 +621,11 @@ ReturnValue_t PlocSupervisorHandler::handleAckReport(const uint8_t* data) {
 
   uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK;
 
-   switch(apid) {
+  switch (apid) {
     case PLOC_SPV::APID_ACK_FAILURE: {
-       //TODO: Interpretation of status field in acknowledgment report
+      // 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 +641,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,11 +652,10 @@ 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);
-    if(result == CRC_FAILURE) {
+  if (result == CRC_FAILURE) {
     sif::error << "PlocSupervisorHandler::handleExecutionReport: CRC failure" << std::endl;
     nextReplyId = PLOC_SPV::NONE;
     return result;
@@ -670,15 +668,16 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data)
       break;
     }
     case (PLOC_SPV::APID_EXE_FAILURE): {
-        //TODO: Interpretation of status field in execution report
+      // 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 +697,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) {
+  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 +750,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 +770,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) {
+  if (result == CRC_FAILURE) {
     sif::error << "PlocSupervisorHandler::handleBootStatusReport: Boot status report has invalid"
-                " crc" << std::endl;
+                  " crc"
+               << std::endl;
     return result;
   }
 
@@ -827,12 +825,11 @@ 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);
 
-    if(result == CRC_FAILURE) {
+  if (result == CRC_FAILURE) {
     sif::error << "PlocSupervisorHandler::handleLatchupStatusReport: Latchup status report has "
                << "invalid crc" << std::endl;
     return result;
@@ -913,15 +910,15 @@ 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;
 }
 
 void PlocSupervisorHandler::setNextReplyId() {
-    switch(getPendingCommand()) {
+  switch (getPendingCommand()) {
     case PLOC_SPV::GET_HK_REPORT:
       nextReplyId = PLOC_SPV::HK_REPORT;
       break;
@@ -944,16 +941,14 @@ void PlocSupervisorHandler::setNextReplyId() {
   }
 }
 
-size_t PlocSupervisorHandler::getNextReplyLength(DeviceCommandId_t commandId){
+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 +965,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 +973,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) {
@@ -1010,7 +1004,7 @@ void PlocSupervisorHandler::prepareEmptyCmd(uint16_t apid) {
   packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
 }
 
-void PlocSupervisorHandler::prepareSelBootImageCmd(const uint8_t * commandData) {
+void PlocSupervisorHandler::prepareSelBootImageCmd(const uint8_t* commandData) {
   PLOC_SPV::MPSoCBootSelect packet(*commandData, *(commandData + 1), *(commandData + 2),
                                    *(commandData + 3));
   packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
@@ -1034,20 +1028,20 @@ void PlocSupervisorHandler::prepareDisableHk() {
   packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
 }
 
-void PlocSupervisorHandler::prepareSetBootTimeoutCmd(const uint8_t * commandData) {
+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());
 }
 
-void PlocSupervisorHandler::prepareRestartTriesCmd(const uint8_t * commandData) {
+void PlocSupervisorHandler::prepareRestartTriesCmd(const uint8_t* commandData) {
   uint8_t restartTries = *(commandData);
   PLOC_SPV::SetRestartTries packet(restartTries);
   packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
 }
 
-void PlocSupervisorHandler::prepareWatchdogsEnableCmd(const uint8_t * commandData) {
+void PlocSupervisorHandler::prepareWatchdogsEnableCmd(const uint8_t* commandData) {
   uint8_t offset = 0;
   uint8_t watchdogPs = *(commandData + offset);
   offset += 1;
@@ -1058,15 +1052,15 @@ void PlocSupervisorHandler::prepareWatchdogsEnableCmd(const uint8_t * commandDat
   packetToOutBuffer(packet.getWholeData(), packet.getFullSize());
 }
 
-ReturnValue_t PlocSupervisorHandler::prepareWatchdogsConfigTimeoutCmd(const uint8_t * commandData) {
+ReturnValue_t PlocSupervisorHandler::prepareWatchdogsConfigTimeoutCmd(const uint8_t* commandData) {
   uint8_t offset = 0;
   uint8_t watchdog = *(commandData + offset);
   offset += 1;
   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 +1101,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 +1127,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 +1138,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 +1164,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,12 +1261,11 @@ void PlocSupervisorHandler::packetToOutBuffer(uint8_t* packetData, size_t fullSi
 }
 
 void PlocSupervisorHandler::disableAllReplies() {
-
   DeviceReplyMap::iterator iter;
 
   /* Disable ack reply */
   iter = deviceReplyMap.find(PLOC_SPV::ACK_REPORT);
-    DeviceReplyInfo *info = &(iter->second);
+  DeviceReplyInfo* info = &(iter->second);
   info->delayCycles = 0;
   info->command = deviceCommandMap.end();
 
@@ -1297,7 +1290,6 @@ void PlocSupervisorHandler::disableAllReplies() {
 }
 
 void PlocSupervisorHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status) {
-
   DeviceReplyIter iter = deviceReplyMap.find(replyId);
 
   if (iter == deviceReplyMap.end()) {
@@ -1308,7 +1300,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;
   }
 
@@ -1320,14 +1313,14 @@ void PlocSupervisorHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnV
 
 void PlocSupervisorHandler::disableExeReportReply() {
   DeviceReplyIter iter = deviceReplyMap.find(PLOC_SPV::EXE_REPORT);
-    DeviceReplyInfo *info = &(iter->second);
+  DeviceReplyInfo* info = &(iter->second);
   info->delayCycles = 0;
   info->command = deviceCommandMap.end();
   /* Expected replies is set to one here. The value will set to 0 in replyToReply() */
   info->command->second.expectedReplies = 1;
 }
 
-ReturnValue_t PlocSupervisorHandler::parseMramPackets(const uint8_t *packet, size_t remainingSize,
+ReturnValue_t PlocSupervisorHandler::parseMramPackets(const uint8_t* packet, size_t remainingSize,
                                                       size_t* foundLen) {
   ReturnValue_t result = IGNORE_FULL_PACKET;
   uint16_t packetLen = 0;
@@ -1359,7 +1352,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 +1364,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++;
@@ -1399,35 +1390,34 @@ void PlocSupervisorHandler::increaseExpectedMramReplies(DeviceCommandId_t id) {
                << "in reply map" << std::endl;
     return;
   }
-    DeviceReplyInfo *mramReplyInfo = &(mramDumpIter->second);
+  DeviceReplyInfo* mramReplyInfo = &(mramDumpIter->second);
   if (mramReplyInfo == nullptr) {
     sif::debug << "PlocSupervisorHandler::increaseExpectedReplies: MRAM reply info nullptr"
                << std::endl;
     return;
   }
-    DeviceReplyInfo *exeReplyInfo = &(exeReportIter->second);
+  DeviceReplyInfo* exeReplyInfo = &(exeReportIter->second);
   if (exeReplyInfo == nullptr) {
     sif::debug << "PlocSupervisorHandler::increaseExpectedReplies: Execution reply info"
                << " nullptr" << std::endl;
     return;
   }
   DeviceCommandInfo* info = &(mramReplyInfo->command->second);
-    if (info == nullptr){
+  if (info == nullptr) {
     sif::debug << "PlocSupervisorHandler::increaseExpectedReplies: Command info nullptr"
                << std::endl;
     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 +1438,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;
@@ -1487,7 +1477,7 @@ ReturnValue_t PlocSupervisorHandler::createMramDumpFile() {
 
   std::string filename = "mram-dump--" + timeStamp + ".bin";
 
-#if BOARD_TE0720 == 0
+#ifdef TE0720_1CFA
   std::string currentMountPrefix = sdcMan->getCurrentMountPrefix();
 #else
   std::string currentMountPrefix("/mnt/sd0");
@@ -1515,8 +1505,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,14 @@
 #ifndef MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
 #define MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_
 
+#include "bsp_q7s/memory/SdCardManager.h"
+#include "fsfw/devicehandlers/DeviceHandlerBase.h"
+#include "fsfw_hal/linux/uart/UartComIF.h"
+#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
+#include "fsfw_hal/linux/gpio/Gpio.h"
+#include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.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>
 
 /**
  * @brief	This is the device handler for the supervisor of the PLOC which is programmed by
@@ -19,26 +22,25 @@
  *          Arbeitsdaten/08_Used%20Components/PLOC&fileid=940960
  * @author	J. Meier
  */
-class PlocSupervisorHandler: public DeviceHandlerBase {
+class PlocSupervisorHandler : public DeviceHandlerBase {
-public:
+ public:
-
+  PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie,
-    PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF * comCookie);
+                        Gpio uartIsolatorSwitch);
   virtual ~PlocSupervisorHandler();
 
   virtual ReturnValue_t initialize() override;
 
-protected:
+ protected:
   void doStartUp() override;
   void doShutDown() override;
-	ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t * id) override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
-	ReturnValue_t buildTransitionDeviceCommand(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,
@@ -48,8 +50,7 @@ protected:
                                       DeviceCommandId_t alternateReplyID = 0) override;
   size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
 
-private:
+ 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 +63,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;
@@ -107,6 +115,8 @@ private:
   DeviceCommandId_t nextReplyId = PLOC_SPV::NONE;
 
   UartComIF* uartComIf = nullptr;
+  LinuxLibgpioIF* gpioComIF = nullptr;
+  Gpio uartIsolatorSwitch;
 
   PLOC_SPV::HkSet hkset;
   PLOC_SPV::BootStatusReport bootStatusReport;
@@ -123,7 +133,7 @@ private:
   /** This buffer is used to concatenate space packets received in two different read steps */
   uint8_t spacePacketBuffer[PLOC_SPV::MAX_PACKET_SIZE];
 
-#if BOARD_TE0720 == 0
+#ifdef TE0720_1CFA
   SdCardManager* sdcMan = nullptr;
 #endif /* BOARD_TE0720 == 0 */
 
@@ -207,7 +217,7 @@ private:
   /**
    * @brief   This function initializes the space packet to select the boot image of the MPSoC.
    */
-	void prepareSelBootImageCmd(const uint8_t * commandData);
+  void prepareSelBootImageCmd(const uint8_t* commandData);
 
   void prepareDisableHk();
 
@@ -221,21 +231,21 @@ private:
    * @brief   This function fills the commandBuffer with the data to change the boot timeout
    *          value in the PLOC supervisor.
    */
-	void prepareSetBootTimeoutCmd(const uint8_t * commandData);
+  void prepareSetBootTimeoutCmd(const uint8_t* commandData);
 
-	void prepareRestartTriesCmd(const uint8_t * commandData);
+  void prepareRestartTriesCmd(const uint8_t* commandData);
 
   /**
    * @brief   This function fills the command buffer with the packet to enable or disable the
    *          watchdogs on the PLOC.
    */
-	void prepareWatchdogsEnableCmd(const uint8_t * commandData);
+  void prepareWatchdogsEnableCmd(const uint8_t* commandData);
 
   /**
    * @brief   This function fills the command buffer with the packet to set the watchdog timer
    *          of one of the three watchdogs (PS, PL, INT).
    */
-	ReturnValue_t prepareWatchdogsConfigTimeoutCmd(const uint8_t * commandData);
+  ReturnValue_t prepareWatchdogsConfigTimeoutCmd(const uint8_t* commandData);
 
   ReturnValue_t prepareLatchupConfigCmd(const uint8_t* commandData,
                                         DeviceCommandId_t deviceCommand);
@@ -256,7 +266,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.
    */
@@ -288,7 +297,7 @@ private:
    * @brief   Function is called in scanForReply and fills the spacePacketBuffer with the read
    *          data until a full packet has been received.
    */
-	ReturnValue_t parseMramPackets(const uint8_t *packet, size_t remainingSize, size_t* foundlen);
+  ReturnValue_t parseMramPackets(const uint8_t* packet, size_t remainingSize, size_t* foundlen);
 
   /**
    * @brief   This function generates the Service 8 packets for the MRAM dump data.

linux/devices/ploc/PlocUpdater.cpp

@@ -16,7 +16,7 @@ PlocUpdater::PlocUpdater(object_id_t objectId)
 PlocUpdater::~PlocUpdater() {}
 
 ReturnValue_t PlocUpdater::initialize() {
-#if BOARD_TE0720 == 0
+#ifdef XIPHOS_Q7S
   sdcMan = SdCardManager::instance();
 #endif
   ReturnValue_t result = SystemObject::initialize();
@@ -163,7 +163,7 @@ ReturnValue_t PlocUpdater::getImageLocation(const uint8_t* data, size_t size) {
     return result;
   }
 
-#if BOARD_TE0720 == 0
+#ifdef XIPHOS_Q7S
   // Check if file is stored on SD card and if associated SD card is mounted
   if (std::string(reinterpret_cast<const char*>(data), SD_PREFIX_LENGTH) ==
       std::string(SdCardManager::SD_0_MOUNT_POINT)) {

linux/devices/ploc/PlocUpdater.h

@@ -1,10 +1,11 @@
 #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 "eive/definitions.h"
 #include "fsfw/action/ActionHelper.h"
 #include "fsfw/action/CommandActionHelper.h"
 #include "fsfw/action/CommandsActionsIF.h"
@@ -13,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"
 
 /**
@@ -103,7 +105,7 @@ class PlocUpdater : public SystemObject,
 
   MessageQueueIF* commandQueue = nullptr;
 
-#if BOARD_TE0720 == 0
+#ifdef XIPHOS_Q7S
   SdCardManager* sdcMan = nullptr;
 #endif
   CommandActionHelper commandActionHelper;

linux/fsfwconfig/OBSWConfig.h.in

@@ -12,11 +12,6 @@
 #cmakedefine EGSE
 #cmakedefine TE0720_1CFA
 
-#ifdef RASPBERRY_PI
-#include "rpiConfig.h"
-#elif defined(XIPHOS_Q7S)
-#include "q7sConfig.h"
-#endif
 #include "commonConfig.h"
 #include "OBSWVersion.h"
 
@@ -24,8 +19,7 @@
 debugging. */
 #define OBSW_VERBOSE_LEVEL                          1
                              
-//! Board defines
+#define Q7S_EM                                      0
-#define BOARD_TE0720                                0                                   
 
 /*******************************************************************/
 /** All of the following flags should be enabled for mission code  */
@@ -37,7 +31,7 @@ debugging. */
 
 #define Q7S_EM                                      0
 
-#define OBSW_USE_CCSDS_IP_CORE                      0
+#define OBSW_USE_CCSDS_IP_CORE                      1
 // Set to 1 if all telemetry should be sent to the PTME IP Core
 #define OBSW_TM_TO_PTME                             0
 // Set to 1 if telecommands are received via the PDEC IP Core
@@ -46,7 +40,7 @@ debugging. */
 #define OBSW_ENABLE_TIMERS                          1
 #define OBSW_ADD_MGT                                1
 #define OBSW_ADD_BPX_BATTERY_HANDLER                1
-#define OBSW_ADD_STAR_TRACKER                       0
+#define OBSW_ADD_STAR_TRACKER                       @OBSW_ADD_STAR_TRACKER@
 #define OBSW_ADD_PLOC_SUPERVISOR                    0
 #define OBSW_ADD_PLOC_MPSOC                         0
 #define OBSW_ADD_SUN_SENSORS                        1
@@ -60,7 +54,8 @@ debugging. */
 #define OBSW_ADD_SYRLINKS                           0
 #define OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT       0
 #define OBSW_STAR_TRACKER_GROUND_CONFIG             1
-#define OBSW_ENABLE_PERIODIC_HK                     0
+
+#endif // XIPHOS_Q7S
 
 // This is a really tricky switch.. It initializes the PCDU switches to their default states
 // at powerup. I think it would be better
@@ -68,12 +63,7 @@ debugging. */
 // something the operators might want to do by giving the software too much intelligence
 // at the wrong place. The system component might command all the Switches accordingly anyway
 #define OBSW_INITIALIZE_SWITCHES                    0
-
+#define OBSW_ENABLE_PERIODIC_HK                     0
-#endif
-
-#ifdef EGSE
-#define OBSW_ADD_STAR_TRACKER                      1
-#endif
 
 #ifdef TE0720_1CFA
 
@@ -102,6 +92,7 @@ debugging. */
 #define OBSW_STAR_TRACKER_GROUND_CONFIG             1
 #define OBSW_ENABLE_PERIODIC_HK                     0
 #define OBSW_PRINT_CORE_HK													0
+#define OBSW_INITIALIZE_SWITCHES                    0
 
 #endif
 
@@ -154,10 +145,16 @@ debugging. */
 #define OBSW_DEBUG_SYRLINKS                         0
 #define OBSW_DEBUG_IMTQ                             0
 #define OBSW_DEBUG_RW                               0
-#define OBSW_DEBUG_PLOC_MPSOC                       0
-#define OBSW_DEBUG_PLOC_SUPERVISOR                  0
 #define OBSW_DEBUG_PDEC_HANDLER	                    0
 
+#ifdef TE0720_1CFA
+#define OBSW_DEBUG_PLOC_SUPERVISOR                  1
+#define OBSW_DEBUG_PLOC_MPSOC                       1
+#else 
+#define OBSW_DEBUG_PLOC_SUPERVISOR                  0
+#define OBSW_DEBUG_PLOC_MPSOC                       0
+#endif 
+
 #ifdef EGSE
 #define OBSW_DEBUG_STARTRACKER                      1
 #else
@@ -171,16 +168,20 @@ debugging. */
 #define OBSW_ADD_PLOC_SUPERVISOR                    0
 #define OBSW_ADD_PLOC_MPSOC                         0
 #define OBSW_ADD_SUN_SENSORS                        0
+#define OBSW_ADD_MGT                                0
 #define OBSW_ADD_ACS_BOARD                          0
 #define OBSW_ADD_GPS_0                              0
 #define OBSW_ADD_GPS_1                              0
 #define OBSW_ADD_RW                                 0
+#define OBSW_ADD_BPX_BATTERY_HANDLER                0
 #define OBSW_ADD_RTD_DEVICES                        0
+#define OBSW_ADD_PL_PCDU                            0
 #define OBSW_ADD_TMP_DEVICES                        0
 #define OBSW_ADD_RAD_SENSORS                        0
 #define OBSW_ADD_SYRLINKS                           0
+#define OBSW_STAR_TRACKER_GROUND_CONFIG             1
 
-#endif
+#endif // RASPBERRY_PI
 
 #define TCP_SERVER_WIRETAPPING                      0
 
@@ -189,7 +190,11 @@ debugging. */
 /*******************************************************************/
 #cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER
 
-#include "OBSWVersion.h"
+#ifdef RASPBERRY_PI
+#include "rpiConfig.h"
+#elif defined(XIPHOS_Q7S)
+#include "q7sConfig.h"
+#endif
 
 #ifdef __cplusplus
 
@@ -197,19 +202,6 @@ debugging. */
 #include "events/subsystemIdRanges.h"
 #include "returnvalues/classIds.h"
 
-namespace config {
-#endif
-
-/* Add mission configuration flags here */
-static constexpr uint32_t OBSW_FILESYSTEM_HANDLER_QUEUE_SIZE = 50;
-static constexpr uint32_t PLOC_UPDATER_QUEUE_SIZE = 50;
-/* Global config values to check validity of received file path strings and filenames */
-static constexpr uint32_t MAX_PATH_SIZE = 100;
-static constexpr uint32_t MAX_FILENAME_SIZE = 50;
-static constexpr uint8_t LIVE_TM = 0;
-
-#ifdef __cplusplus
-}
 #endif
 
 #endif /* FSFWCONFIG_OBSWCONFIG_H_ */

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
  * @brief    Auto-generated event translation file. Contains 169 translations.
  * @details
- * Generated on: 2022-03-25 18:53:13
+ * Generated on: 2022-03-28 09:51:17
  */
 #include "translateEvents.h"
 

linux/fsfwconfig/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 117 translations.
- * Generated on: 2022-03-25 18:53:22
+ * Generated on: 2022-03-28 09:51:13
  */
 #include "translateObjects.h"
 

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -592,68 +592,3 @@ ReturnValue_t pst::pstTest(FixedTimeslotTaskIF *thisSequence) {
   }
   return HasReturnvaluesIF::RETURN_OK;
 }
-
-#if BOARD_TE0720 == 1
-ReturnValue_t pst::pollingSequenceTE0720(FixedTimeslotTaskIF *thisSequence) {
-  uint32_t length = thisSequence->getPeriodMs();
-
-#if OBSW_ADD_PLOC_MPSOC == 1
-    thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
-#endif
-
-#if OBSW_TEST_RAD_SENSOR == 1
-  thisSequence->addSlot(objects::RAD_SENSOR, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RAD_SENSOR, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RAD_SENSOR, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RAD_SENSOR, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RAD_SENSOR, length * 0.8, DeviceHandlerIF::GET_READ);
-#endif
-
-#if OBSW_TEST_SUS == 1
-  /* Write setup */
-  thisSequence->addSlot(objects::SUS_1, length * 0.901, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_1, length * 0.902, SusHandler::FIRST_WRITE);
-  thisSequence->addSlot(objects::SUS_1, length * 0.903, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_1, length * 0.904, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_1, length * 0.905, DeviceHandlerIF::GET_READ);
-
-  /* Start conversion*/
-  thisSequence->addSlot(objects::SUS_1, length * 0.906, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_1, length * 0.907, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_1, length * 0.908, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_1, length * 0.909, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_1, length * 0.91, DeviceHandlerIF::GET_READ);
-
-  /* Read conversions */
-  thisSequence->addSlot(objects::SUS_1, length * 0.911, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_1, length * 0.912, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_1, length * 0.913, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_1, length * 0.914, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_1, length * 0.915, DeviceHandlerIF::GET_READ);
-#endif
-
-#if OBSW_ADD_PLOC_SUPERVISOR == 1
-  thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.2,
-                        DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::PLOC_SUPERVISOR_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
-#endif
-
-  thisSequence->addSlot(objects::PLOC_UPDATER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::PLOC_MEMORY_DUMPER, length * 0,
-                        DeviceHandlerIF::PERFORM_OPERATION);
-
-  if (thisSequence->checkSequence() != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "Initialization of TE0720 PST failed" << std::endl;
-    return HasReturnvaluesIF::RETURN_FAILED;
-  }
-  return HasReturnvaluesIF::RETURN_OK;
-}
-#endif /* BOARD_TE0720 == 1 */

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.h

@@ -54,14 +54,6 @@ ReturnValue_t pstI2c(FixedTimeslotTaskIF* thisSequence);
  * @return
  */
 ReturnValue_t pstTest(FixedTimeslotTaskIF* thisSequence);
-
-#if BOARD_TE0720 == 1
-/**
- * @brief   This polling sequence will be created when the software is compiled for the TE0720.
- */
-ReturnValue_t pollingSequenceTE0720(FixedTimeslotTaskIF* thisSequence);
-#endif
-
 }  // namespace pst
 
 #endif /* POLLINGSEQUENCEINIT_H_ */

linux/obc/PdecHandler.h

@@ -153,7 +153,7 @@ class PdecHandler : public SystemObject,
   static const uint32_t PDEC_SLEN_OFFSET = 0xA26;
   static const uint32_t PDEC_MON_OFFSET = 0xA27;
 
-#if BOARD_TE0720 == 1
+#ifdef TE0720_1CFA
   static const int CONFIG_MEMORY_MAP_SIZE = 0x400;
   static const int RAM_MAP_SIZE = 0x4000;
   static const int REGISTER_MAP_SIZE = 0x10000;
@@ -169,7 +169,7 @@ class PdecHandler : public SystemObject,
   static const size_t MAX_TC_SEGMENT_SIZE = 1017;
   static const uint8_t MAP_ID_MASK = 0x3F;
 
-#if BOARD_TE0720 == 1
+#ifdef TE0720_1CFA
   static const uint32_t PHYSICAL_RAM_BASE_ADDRESS = 0x32000000;
 #else
   static const uint32_t PHYSICAL_RAM_BASE_ADDRESS = 0x26000000;

misc/eclipse/.cproject

@@ -589,7 +589,7 @@
 		<cconfiguration id="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689">
 			<storageModule buildSystemId="org.eclipse.cdt.managedbuilder.core.configurationDataProvider" id="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689" moduleId="org.eclipse.cdt.core.settings" name="eive-q7s-debug">
 				<macros>
-					<stringMacro name="Q7S_SYSROOT_UNIX" type="VALUE_PATH_DIR" value="/home/rmueller/Xilinx/cortexa9hf-neon-xiphos-linux-gnueabi"/>
+					<stringMacro name="Q7S_SYSROOT_UNIX" type="VALUE_PATH_DIR" value="${HOME}/Xilinx/cortexa9hf-neon-xiphos-linux-gnueabi"/>
 					<stringMacro name="Q7S_SYSROOT" type="VALUE_TEXT" value="C:\Xilinx\cortexa9hf-neon-xiphos-linux-gnueabi"/>
 				</macros>
 				<externalSettings/>

mission/core/GenericFactory.cpp

@@ -1,6 +1,5 @@
 #include "GenericFactory.h"
 
-#include <OBSWConfig.h>
 #include <fsfw/events/EventManager.h>
 #include <fsfw/health/HealthTable.h>
 #include <fsfw/internalerror/InternalErrorReporter.h>
@@ -18,10 +17,12 @@
 #include <fsfw/tcdistribution/PUSDistributor.h>
 #include <fsfw/timemanager/TimeStamper.h>
 #include <mission/utility/TmFunnel.h>
-#include <tmtc/apid.h>
-#include <tmtc/pusIds.h>
 
+#include "OBSWConfig.h"
+#include "eive/definitions.h"
 #include "objects/systemObjectList.h"
+#include "tmtc/apid.h"
+#include "tmtc/pusIds.h"
 
 #if OBSW_ADD_TCPIP_BRIDGE == 1
 #if OBSW_USE_TMTC_TCP_BRIDGE == 0
@@ -39,6 +40,10 @@
 #include <test/testtasks/TestTask.h>
 #endif
 
+#ifndef OBSW_TM_TO_PTME
+#define OBSW_TM_TO_PTME 0
+#endif
+
 void ObjectFactory::produceGenericObjects() {
   // Framework objects
   new EventManager(objects::EVENT_MANAGER);
@@ -68,8 +73,12 @@ void ObjectFactory::produceGenericObjects() {
   new PUSDistributor(apid::EIVE_OBSW, objects::PUS_PACKET_DISTRIBUTOR,
                      objects::CCSDS_PACKET_DISTRIBUTOR);
 
+  uint8_t vc = 0;
+#if OBSW_TM_TO_PTME == 1
+  vc = config::LIVE_TM;
+#endif
   // Every TM packet goes through this funnel
-  new TmFunnel(objects::TM_FUNNEL, 50);
+  new TmFunnel(objects::TM_FUNNEL, 50, vc);
 
   // PUS service stack
   new Service1TelecommandVerification(objects::PUS_SERVICE_1_VERIFICATION, apid::EIVE_OBSW,
@@ -87,7 +96,7 @@ void ObjectFactory::produceGenericObjects() {
   new Service20ParameterManagement(objects::PUS_SERVICE_20_PARAMETERS, apid::EIVE_OBSW,
                                    pus::PUS_SERVICE_20);
   new CService200ModeCommanding(objects::PUS_SERVICE_200_MODE_MGMT, apid::EIVE_OBSW,
-                                pus::PUS_SERVICE_200);
+                                pus::PUS_SERVICE_200, 8, config::LONGEST_MODE_TIMEOUT_SECONDS);
 
 #if OBSW_ADD_TCPIP_BRIDGE == 1
 #if OBSW_USE_TMTC_TCP_BRIDGE == 0

mission/devices/Max31865PT1000Handler.cpp

@@ -403,9 +403,9 @@ ReturnValue_t Max31865PT1000Handler::interpretDeviceReply(DeviceCommandId_t id,
 #if OBSW_VERBOSE_LEVEL >= 1
       if (debugDivider->checkAndIncrement()) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::info << "Max31865: Object ID: " << std::hex << this->getObjectId()
+        sif::info << "Max31865: ObjID " << std::hex << this->getObjectId() << " | RTD " << std::dec
-                  << ": Measured resistance is " << rtdValue << " Ohms." << std::endl;
+                  << static_cast<int>(deviceIdx) << ": R[Ohm] " << rtdValue
-        sif::info << "Approximated temperature is " << approxTemp << " C" << std::endl;
+                  << " Ohms | Approx T[C]: " << approxTemp << std::endl;
 #else
         sif::printInfo("Max31685: Measured resistance is %f Ohms\n", rtdValue);
         sif::printInfo("Approximated temperature is %f C\n", approxTemp);
@@ -529,3 +529,5 @@ void Max31865PT1000Handler::modeChanged() {
     internalState = InternalState::NONE;
   }
 }
+
+void Max31865PT1000Handler::setDeviceIdx(uint8_t idx) { deviceIdx = idx; }

mission/devices/Max31865PT1000Handler.h

@@ -46,6 +46,8 @@ class Max31865PT1000Handler : public DeviceHandlerBase {
   static constexpr uint8_t DEFAULT_CONFIG = 0b11000001;
 
   void setInstantNormal(bool instantNormal);
+  void setDeviceIdx(uint8_t idx);
+
   /**
    * Expected temperature range is -100 C and 100 C.
    * If there are temperatures beyond this range there must be a fault.
@@ -105,6 +107,7 @@ class Max31865PT1000Handler : public DeviceHandlerBase {
   bool resetFaultBit = false;
   dur_millis_t startTime = 0;
   uint8_t faultByte = 0;
+  uint8_t deviceIdx = 0;
   std::array<uint8_t, 3> commandBuffer{0};
 
   Max31865Definitions::Max31865Set sensorDataset;

mission/devices/PCDUHandler.cpp

@@ -419,7 +419,7 @@ ReturnValue_t PCDUHandler::initializeLocalDataPool(localpool::DataPool& localDat
       new PoolEntry<uint8_t>({INIT_SWITCH_STATES[Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8]}));
   localDataPoolMap.emplace(P60System::PDU2_OUT_EN_RW,
                            new PoolEntry<uint8_t>({INIT_SWITCH_STATES[Switches::PDU2_CH2_RW_5V]}));
-#if BOARD_TE0720 == 1
+#ifdef TE0720_1CFA
   localDataPoolMap.emplace(P60System::PDU2_OUT_EN_TCS_BOARD_HEATER_IN, new PoolEntry<uint8_t>({1}));
 #else
   localDataPoolMap.emplace(

mission/devices/PDU2Handler.cpp

@@ -306,7 +306,7 @@ ReturnValue_t PDU2Handler::initializeLocalDataPool(localpool::DataPool &localDat
   localDataPoolMap.emplace(P60System::PDU2_OUT_EN_Q7S, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(P60System::PDU2_OUT_EN_PAYLOAD_PCDU_CH1, new PoolEntry<uint8_t>({0}));
   localDataPoolMap.emplace(P60System::PDU2_OUT_EN_RW, new PoolEntry<uint8_t>({0}));
-#if BOARD_TE0720 == 1
+#ifdef TE0720_1CFA
   localDataPoolMap.emplace(P60System::PDU2_OUT_EN_TCS_BOARD_HEATER_IN, new PoolEntry<uint8_t>({1}));
 #else
   localDataPoolMap.emplace(P60System::PDU2_OUT_EN_TCS_BOARD_HEATER_IN, new PoolEntry<uint8_t>({0}));

mission/system/TcsBoardAssembly.h

@@ -14,8 +14,7 @@ struct TcsBoardHelper {
 class TcsBoardAssembly : public AssemblyBase, public ConfirmsFailuresIF {
  public:
   static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_BOARD_ASS;
-  static constexpr Event CHILDREN_LOST_MODE =
+  static constexpr Event CHILDREN_LOST_MODE = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
-      event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
 
   TcsBoardAssembly(object_id_t objectId, object_id_t parentId, PowerSwitchIF* pwrSwitcher,
                    power::Switch_t switcher, TcsBoardHelper helper);

mission/tmtc/CCSDSHandler.cpp

@@ -12,7 +12,7 @@
 
 CCSDSHandler::CCSDSHandler(object_id_t objectId, object_id_t ptmeId, object_id_t tcDestination,
                            PtmeConfig* ptmeConfig, GpioIF* gpioIF, gpioId_t enTxClock,
-                           gpioId_t enTxData)
+                           gpioId_t enTxData, uint32_t transmitterTimeout)
     : SystemObject(objectId),
       ptmeId(ptmeId),
       tcDestination(tcDestination),
@@ -21,7 +21,8 @@ CCSDSHandler::CCSDSHandler(object_id_t objectId, object_id_t ptmeId, object_id_t
       ptmeConfig(ptmeConfig),
       gpioIF(gpioIF),
       enTxClock(enTxClock),
-      enTxData(enTxData) {
+      enTxData(enTxData),
+      TRANSMITTER_TIMEOUT(transmitterTimeout) {
   commandQueue = QueueFactory::instance()->createMessageQueue(QUEUE_SIZE);
   auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
   eventQueue =
@@ -312,7 +313,7 @@ void CCSDSHandler::enableTransmit() {
     return;
   }
   transmitterCountdown.setTimeout(TRANSMITTER_TIMEOUT);
-#if BOARD_TE0720 == 0
+#ifdef TE0720_1CFA
   gpioIF->pullHigh(enTxClock);
   gpioIF->pullHigh(enTxData);
 #endif /* BOARD_TE0720 == 0 */
@@ -331,7 +332,7 @@ void CCSDSHandler::checkTxTimer() {
 }
 
 void CCSDSHandler::disableTransmit() {
-#if BOARD_TE0720 == 0
+#ifdef TE0720_1CFA
   gpioIF->pullLow(enTxClock);
   gpioIF->pullLow(enTxData);
 #endif /* BOARD_TE0720 == 0 */

mission/tmtc/CCSDSHandler.h

@@ -51,7 +51,8 @@ class CCSDSHandler : public SystemObject,
    * @param enTxData  GPIO ID of RS485 tx data enable
    */
   CCSDSHandler(object_id_t objectId, object_id_t ptmeId, object_id_t tcDestination,
-               PtmeConfig* ptmeConfig, GpioIF* gpioIF, gpioId_t enTxClock, gpioId_t enTxData);
+               PtmeConfig* ptmeConfig, GpioIF* gpioIF, gpioId_t enTxClock, gpioId_t enTxData,
+               uint32_t transmitterTimeout = 900000);
 
   ~CCSDSHandler();
 
@@ -104,14 +105,6 @@ class CCSDSHandler : public SystemObject,
   //! [EXPORT] : [COMMENT] Received action message with unknown action id
   static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xA0);
 
-#if OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT == 1
-  // syrlinks must not be transmitting more than 15 minutes (according to datasheet)
-  static const uint32_t TRANSMITTER_TIMEOUT = 900000;  // 900000 ms = 15 min
-#else
-  // Set to high value when not sending via syrlinks
-  static const uint32_t TRANSMITTER_TIMEOUT = 86400000;  // 1 day
-#endif /* OBSW_SYRLINKS_DOWNLINK == 0 */
-
   static const bool UP = true;
   static const bool DOWN = false;
 
@@ -140,6 +133,10 @@ class CCSDSHandler : public SystemObject,
   gpioId_t enTxClock = gpio::NO_GPIO;
   gpioId_t enTxData = gpio::NO_GPIO;
 
+  // syrlinks must not be transmitting more than 15 minutes (according to datasheet)
+  // Value can be configured via CTOR argument to allow test setups
+  const uint32_t TRANSMITTER_TIMEOUT = 900000;  // 900000 ms = 15 min
+
   // Countdown to disable transmitter after 15 minutes
   Countdown transmitterCountdown;
 

mission/utility/TmFunnel.cpp

@@ -9,8 +9,8 @@
 object_id_t TmFunnel::downlinkDestination = objects::NO_OBJECT;
 object_id_t TmFunnel::storageDestination = objects::NO_OBJECT;
 
-TmFunnel::TmFunnel(object_id_t objectId, uint32_t messageDepth)
+TmFunnel::TmFunnel(object_id_t objectId, uint32_t messageDepth, uint8_t reportReceptionVc)
-    : SystemObject(objectId), messageDepth(messageDepth) {
+    : SystemObject(objectId), messageDepth(messageDepth), reportReceptionVc(reportReceptionVc) {
   auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
   tmQueue = QueueFactory::instance()->createMessageQueue(
       messageDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
@@ -97,12 +97,7 @@ ReturnValue_t TmFunnel::initialize() {
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
-#if OBSW_TM_TO_PTME == 1
+  tmQueue->setDefaultDestination(tmTarget->getReportReceptionQueue(reportReceptionVc));
-  // Live TM will be sent via the virtual channel 0
-  tmQueue->setDefaultDestination(tmTarget->getReportReceptionQueue(config::LIVE_TM));
-#else
-  tmQueue->setDefaultDestination(tmTarget->getReportReceptionQueue());
-#endif /* OBSW_TM_TO_PTME == 1 */
 
   // Storage destination is optional.
   if (storageDestination == objects::NO_OBJECT) {

mission/utility/TmFunnel.h

@@ -23,7 +23,7 @@ class TmFunnel : public AcceptsTelemetryIF, public ExecutableObjectIF, public Sy
   friend void(Factory::setStaticFrameworkObjectIds)();
 
  public:
-  TmFunnel(object_id_t objectId, uint32_t messageDepth = 20);
+  TmFunnel(object_id_t objectId, uint32_t messageDepth = 20, uint8_t reportReceptionVc = 0);
   virtual ~TmFunnel();
 
   virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) override;
@@ -35,12 +35,13 @@ class TmFunnel : public AcceptsTelemetryIF, public ExecutableObjectIF, public Sy
   static object_id_t storageDestination;
 
  private:
+  uint32_t messageDepth = 0;
+  uint8_t reportReceptionVc = 0;
   uint16_t sourceSequenceCount = 0;
   MessageQueueIF* tmQueue = nullptr;
   MessageQueueIF* storageQueue = nullptr;
 
   StorageManagerIF* tmStore = nullptr;
-  uint32_t messageDepth = 0;
 
   ReturnValue_t handlePacket(TmTcMessage* message);
 };

test/CMakeLists.txt

@@ -1 +1,2 @@
 add_subdirectory(testtasks)
+add_subdirectory(gpio)

test/gpio/CMakeLists.txt

@@ -0,0 +1,7 @@
+target_sources(${OBSW_NAME} PUBLIC
+	DummyGpioIF.cpp
+)
+
+target_include_directories(${OBSW_NAME} PUBLIC
+	${CMAKE_CURRENT_SOURCE_DIR}
+)

test/gpio/DummyGpioIF.cpp

@@ -0,0 +1,24 @@
+#include "DummyGpioIF.h"
+
+DummyGpioIF::DummyGpioIF() {
+}
+
+DummyGpioIF::~DummyGpioIF() {
+}
+
+ReturnValue_t DummyGpioIF::addGpios(GpioCookie* cookie) {
+    return RETURN_OK;
+}
+
+ReturnValue_t DummyGpioIF::pullHigh(gpioId_t gpioId) {
+    return RETURN_OK;
+}
+
+ReturnValue_t DummyGpioIF::pullLow(gpioId_t gpioId) {
+    return RETURN_OK;
+}
+
+ReturnValue_t DummyGpioIF::readGpio(gpioId_t gpioId, int* gpioState) {
+    *gpioState = 0;
+    return RETURN_OK;
+}

test/gpio/DummyGpioIF.h

@@ -0,0 +1,16 @@
+#ifndef TEST_GPIO_DUMMYGPIOIF_H_
+#define TEST_GPIO_DUMMYGPIOIF_H_
+
+#include "fsfw_hal/common/gpio/GpioIF.h"
+
+class DummyGpioIF : public GpioIF {
+ public:
+  DummyGpioIF();
+  virtual ~DummyGpioIF();
+  virtual ReturnValue_t addGpios(GpioCookie* cookie);
+  virtual ReturnValue_t pullHigh(gpioId_t gpioId);
+  virtual ReturnValue_t pullLow(gpioId_t gpioId);
+  virtual ReturnValue_t readGpio(gpioId_t gpioId, int* gpioState);
+};
+
+#endif /* TEST_GPIO_DUMMYGPIOIF_H_ */

test/gpio/GpioDummy.h

@@ -0,0 +1,30 @@
+#ifndef TEST_GPIODUMMY_H_
+#define TEST_GPIODUMMY_H_
+
+#include "fsfw_hal/common/gpio/GpioIF.h"
+#include "fsfw_hal/common/gpio/gpioDefinitions.h"
+
+/**
+ * @brief   Additional abstraction layer for handling GPIOs.
+ *
+ * @author  J. Meier
+ */
+class Gpio {
+ public:
+  Gpio(gpioId_t gpioId, GpioIF* gpioIF) : gpioId(gpioId), gpioIF(gpioIF) {
+      if (gpioIF == nullptr) {
+          sif::error << "Gpio::Gpio: Invalid GpioIF" << std::endl;
+      }
+  }
+  ReturnValue_t pullHigh() {
+      return gpioIF->pullHigh(gpioId);
+  }
+  ReturnValue_t pullLow() {
+      return gpioIF->pullLow(gpioId);
+  }
+ private:
+  gpioId_t gpioId = gpio::NO_GPIO;
+  GpioIF* gpioIF = nullptr;
+};
+
+#endif /* TEST_GPIODUMMY_H_ */