Merge remote-tracking branch 'origin/develop' into mueller/rpi-sus-port

CMakeLists.txt

@@ -74,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)
@@ -100,7 +100,8 @@ pre_source_hw_os_config()
 
 if(TGT_BSP)
     if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/raspberrypi"
-        OR TGT_BSP MATCHES "arm/beagleboneblack" OR TGT_BSP MATCHES "arm/egse"
+        OR TGT_BSP MATCHES "arm/beagleboneblack" OR TGT_BSP MATCHES "arm/egse" 
+        OR TGT_BSP MATCHES "arm/te0720-1cfa"
     )
         set(FSFW_CONFIG_PATH "linux/fsfwconfig")
         if(NOT BUILD_Q7S_SIMPLE_MODE)
@@ -133,6 +134,10 @@ if(TGT_BSP)
         # Used by configure file
         set(XIPHOS_Q7S ON)
     endif()
+    
+    if(TGT_BSP MATCHES "arm/te0720-1cfa")
+        set(TE0720_1CFA ON)
+    endif()
 else()
     # Required by FSFW library
     set(FSFW_CONFIG_PATH "${BSP_PATH}/fsfwconfig")
@@ -205,7 +210,7 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
 	set(COMPILER_FLAGS "/permissive-")
 endif()
 
-
+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")
@@ -223,7 +228,7 @@ if(NOT Catch2_FOUND)
     set_target_properties(Catch2 PROPERTIES EXCLUDE_FROM_ALL "true")
     set_target_properties(Catch2WithMain PROPERTIES EXCLUDE_FROM_ALL "true")
 endif()
-
+endif()
 
 
 add_library(${LIB_EIVE_MISSION})

automation/Dockerfile

@@ -16,5 +16,5 @@ RUN mkdir -p /usr/tools; \
 curl https://buggy.irs.uni-stuttgart.de/eive/tools/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf.tar.gz \
     | tar -xz -C /usr/tools
 
-ENV Q7S_SYSROOT="/usr/rootfs/cortexa9hf-neon-xiphos-linux-gnueabi"
+ENV ZYNQ_7020_SYSROOT="/usr/rootfs/cortexa9hf-neon-xiphos-linux-gnueabi"
-ENV PATH=$PATH:"/usr/tools/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin"
+ENV PATH=$PATH:"/usr/tools/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin"

automation/Jenkinsfile

@@ -5,7 +5,7 @@ pipeline {
     }
     agent {
         docker {
-            image 'eive-obsw-ci:d2'
+            image 'eive-obsw-ci:d3'
             args '--sysctl fs.mqueue.msg_max=100'
         }
     }

bsp_egse/ObjectFactory.cpp

@@ -3,7 +3,6 @@
 #include <devConf.h>
 #include <fsfw_hal/linux/uart/UartComIF.h>
 #include <fsfw_hal/linux/uart/UartCookie.h>
-#include <mission/devices/GPSHyperionHandler.h>
 
 #include "OBSWConfig.h"
 #include "busConf.h"

bsp_egse/main.cpp

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

bsp_q7s/CMakeLists.txt

@@ -22,5 +22,4 @@ add_subdirectory(comIF)
 add_subdirectory(core)
 add_subdirectory(memory)
 add_subdirectory(callbacks)
-add_subdirectory(devices)
 add_subdirectory(xadc)

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,7 +156,14 @@ 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);
+  result = mpsocHelperTask->addComponent(objects::PLOC_MPSOC_HELPER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER);
+  }
+#endif /* OBSW_ADD_PLOC_MPSOC */
 
 #if OBSW_TEST_CCSDS_BRIDGE == 1
   PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask(
@@ -203,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");
@@ -217,12 +219,10 @@ void initmission::initTasks() {
   ptmeTestTask->startTask();
 #endif
 
-#if BOARD_TE0720 == 0
   fsTask->startTask();
 #if OBSW_ADD_STAR_TRACKER == 1
-  strHelperTask > startTask();
+  strHelperTask->startTask();
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
-#endif
 
 #if OBSW_ADD_ACS_HANDLERS == 1
   acsTask->startTask();
@@ -236,7 +236,6 @@ 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(
@@ -302,15 +301,6 @@ void initmission::createPstTasks(TaskFactory& factory,
     }
   }
   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);
-#endif /* BOARD_TE7020 == 1 */
 }
 
 void initmission::createPusTasks(TaskFactory& factory,
@@ -417,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

@@ -7,9 +7,6 @@
 #include "bsp_q7s/callbacks/q7sGpioCallbacks.h"
 #include "bsp_q7s/callbacks/rwSpiCallback.h"
 #include "bsp_q7s/core/CoreController.h"
-#include "bsp_q7s/devices/PlocMemoryDumper.h"
-#include "bsp_q7s/devices/PlocSupervisorHandler.h"
-#include "bsp_q7s/devices/PlocUpdater.h"
 #include "bsp_q7s/memory/FileSystemHandler.h"
 #include "busConf.h"
 #include "ccsdsConfig.h"
@@ -26,7 +23,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 "linux/obc/AxiPtmeConfig.h"
@@ -53,6 +56,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"
@@ -75,7 +79,6 @@
 #include "mission/devices/PDU1Handler.h"
 #include "mission/devices/PDU2Handler.h"
 #include "mission/devices/PayloadPcduHandler.h"
-#include "mission/devices/PlocMPSoCHandler.h"
 #include "mission/devices/RadiationSensorHandler.h"
 #include "mission/devices/RwHandler.h"
 #include "mission/devices/SolarArrayDeploymentHandler.h"
@@ -84,7 +87,6 @@
 #include "mission/devices/Tmp1075Handler.h"
 #include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
 #include "mission/devices/devicedefinitions/Max31865Definitions.h"
-#include "mission/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #include "mission/devices/devicedefinitions/RadSensorDefinitions.h"
 #include "mission/devices/devicedefinitions/RwDefinitions.h"
 #include "mission/devices/devicedefinitions/SusDefinitions.h"
@@ -107,8 +109,8 @@ void Factory::setStaticFrameworkObjectIds() {
   CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
   CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
 
-  // DeviceHandlerBase::powerSwitcherId = objects::PCDU_HANDLER;
+  DeviceHandlerBase::powerSwitcherId = objects::PCDU_HANDLER;
-  DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+  //  DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
 
 #if OBSW_TM_TO_PTME == 1
   TmFunnel::downlinkDestination = objects::CCSDS_HANDLER;
@@ -135,7 +137,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(gpioComIF);
@@ -154,6 +155,7 @@ void ObjectFactory::produce(void* args) {
   createSyrlinksComponents();
 #endif /* OBSW_ADD_SYRLINKS == 1 */
   createRtdComponents(gpioComIF, pwrSwitcher);
+  createPayloadComponents(gpioComIF);
 
 #if OBSW_ADD_MGT == 1
   I2cCookie* imtqI2cCookie =
@@ -181,29 +183,12 @@ 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, PLOC_MPSOC::MAX_REPLY_SIZE);
-  new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, plocMpsocCookie);
-#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
   UartCookie* starTrackerCookie =
       new UartCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, UartModes::NON_CANONICAL,
-                     uart::STAR_TRACKER_BAUD, StarTracker::MAX_FRAME_SIZE * 2 + 2);
+                     uart::STAR_TRACKER_BAUD, startracker::MAX_FRAME_SIZE * 2 + 2);
   starTrackerCookie->setNoFixedSizeReply();
   StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
   StarTrackerHandler* starTrackerHandler = new StarTrackerHandler(
@@ -212,8 +197,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 */
@@ -228,17 +211,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 =
@@ -263,10 +239,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 */
   q7s::gpioCallbacks::initSpiCsDecoder(*gpioComIF);
-#endif
 }
 
 void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher) {
@@ -782,6 +756,44 @@ 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();
+  new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF,
+                            supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF));
+#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
+  static_cast<void>(consumer);
+}
+
 void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
   using namespace gpio;
   GpioCookie* gpioCookieRw = new GpioCookie;
@@ -966,7 +978,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);
@@ -984,7 +995,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) {
@@ -1037,112 +1047,19 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF*
       new PayloadPcduHandler(objects::PLPCDU_HANDLER, objects::SPI_COM_IF, spiCookie, gpioComIF,
                              SdCardManager::instance(), false);
   spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler);
-  static_cast<void>(plPcduHandler);
+//  plPcduHandler->enablePeriodicPrintout(true, 5);
+//  static_cast<void>(plPcduHandler);
 #if OBSW_TEST_PL_PCDU == 1
   plPcduHandler->setStartUpImmediately();
 #endif
 #if OBSW_DEBUG_PL_PCDU == 1
   plPcduHandler->setToGoToNormalModeImmediately(true);
-  plPcduHandler->enablePeriodicPrintout(true, 5);
+  plPcduHandler->enablePeriodicPrintout(true, 10);
 #endif
 }
 
 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* plocUartCookie =
-      new UartCookie(std::string("/dev/ttyPS1"), 115200, PLOC_MPSOC::MAX_REPLY_SIZE);
-  /* Testing PlocMPSoCHandler on TE0720-03-1CFA */
-  PlocMPSoCHandler* mpsocPlocHandler =
-      new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, plocUartCookie);
-  mpsocPlocHandler->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

@@ -24,6 +24,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/CMakeLists.txt

@@ -2,4 +2,5 @@ target_sources(${OBSW_NAME} PRIVATE
     FileSystemHandler.cpp
     SdCardManager.cpp
     scratchApi.cpp
+    FilesystemHelper.cpp
 )

bsp_q7s/memory/FilesystemHelper.cpp

@@ -0,0 +1,40 @@
+#include "FilesystemHelper.h"
+
+#include <filesystem>
+#include <fstream>
+
+#include "bsp_q7s/memory/SdCardManager.h"
+#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
+
+FilesystemHelper::FilesystemHelper() {}
+
+FilesystemHelper::~FilesystemHelper() {}
+
+ReturnValue_t FilesystemHelper::checkPath(std::string path) {
+  SdCardManager* sdcMan = SdCardManager::instance();
+  if (sdcMan == nullptr) {
+    sif::warning << "FilesystemHelper::checkPath: Invalid SD card manager" << std::endl;
+    return RETURN_FAILED;
+  }
+  if (path.substr(0, sizeof(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)) ==
+             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;
+    }
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t FilesystemHelper::fileExists(std::string file) {
+  if (not std::filesystem::exists(file)) {
+    return FILE_NOT_EXISTS;
+  }
+  return RETURN_OK;
+}

bsp_q7s/memory/FilesystemHelper.h

@@ -0,0 +1,49 @@
+#ifndef BSP_Q7S_MEMORY_FILESYSTEMHELPER_H_
+#define BSP_Q7S_MEMORY_FILESYSTEMHELPER_H_
+
+#include <string>
+
+#include "commonClassIds.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
+/**
+ * @brief   This class implements often used functions concerning the file system management.
+ *
+ * @author  J. Meier
+ */
+class FilesystemHelper : public HasReturnvaluesIF {
+ public:
+  static const uint8_t INTERFACE_ID = CLASS_ID::FILE_SYSTEM_HELPER;
+
+  //! [EXPORT] : [COMMENT] SD card specified with path string not mounted
+  static const ReturnValue_t SD_NOT_MOUNTED = MAKE_RETURN_CODE(0xA0);
+  //! [EXPORT] : [COMMENT] Specified file does not exist on filesystem
+  static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xA1);
+
+  FilesystemHelper();
+  virtual ~FilesystemHelper();
+
+  /**
+   * @brief   In case the path points to a directory on the sd card the function checks if the
+   *          appropriate SD card is mounted.
+   *
+   * @param path  Path to check
+   *
+   * @return  RETURN_OK if path points to SD card and the appropriate SD card is mounted or if
+   *          path does not point to SD card.
+   *          Return error code if path points to SD card and the corresponding SD card is not
+   *          mounted.
+   */
+  static ReturnValue_t checkPath(std::string path);
+
+  /**
+   * @brief   Checks if the file exists on the filesystem.
+   *
+   * param file   File to check
+   *
+   * @return  RETURN_OK if fiel exists, otherwise return error code.
+   */
+  static ReturnValue_t fileExists(std::string file);
+};
+
+#endif /* BSP_Q7S_MEMORY_FILESYSTEMHELPER_H_ */

bsp_te0720_1cfa/CMakeLists.txt

@@ -0,0 +1,7 @@
+target_sources(${OBSW_NAME} PUBLIC
+	InitMission.cpp
+	main.cpp
+	ObjectFactory.cpp
+)
+
+add_subdirectory(boardconfig)

bsp_te0720_1cfa/InitMission.cpp

@@ -0,0 +1,188 @@
+#include "InitMission.h"
+
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw/tasks/FixedTimeslotTaskIF.h>
+#include <fsfw/tasks/PeriodicTaskIF.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <mission/utility/InitMission.h>
+
+#include <iostream>
+
+#include "OBSWConfig.h"
+#include "ObjectFactory.h"
+#include "objects/systemObjectList.h"
+#include "pollingsequence/pollingSequenceFactory.h"
+
+ServiceInterfaceStream sif::debug("DEBUG");
+ServiceInterfaceStream sif::info("INFO");
+ServiceInterfaceStream sif::warning("WARNING");
+ServiceInterfaceStream sif::error("ERROR");
+
+ObjectManagerIF* objectManager = nullptr;
+
+void initmission::initMission() {
+  sif::info << "Building global objects.." << std::endl;
+  /* Instantiate global object manager and also create all objects */
+  ObjectManager::instance()->setObjectFactoryFunction(ObjectFactory::produce, nullptr);
+  sif::info << "Initializing all objects.." << std::endl;
+  ObjectManager::instance()->initialize();
+
+  /* This function creates and starts all tasks */
+  initTasks();
+}
+
+void initmission::initTasks() {
+  TaskFactory* factory = TaskFactory::instance();
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  if (factory == nullptr) {
+    /* Should never happen ! */
+    return;
+  }
+#if OBSW_PRINT_MISSED_DEADLINES == 1
+  void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
+#else
+  void (*missedDeadlineFunc)(void) = nullptr;
+#endif
+
+  /* TMTC Distribution */
+  PeriodicTaskIF* tmtcDistributor = factory->createPeriodicTask(
+      "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = tmtcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmtcDistributor->addComponent(objects::PUS_PACKET_DISTRIBUTOR);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  result = tmtcDistributor->addComponent(objects::TM_FUNNEL);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+
+  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
+      "TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Add component TMTC Bridge failed" << std::endl;
+  }
+  PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
+      "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Add component TMTC Polling failed" << std::endl;
+  }
+
+  /* PUS Services */
+  std::vector<PeriodicTaskIF*> pusTasks;
+  createPusTasks(*factory, missedDeadlineFunc, pusTasks);
+
+  std::vector<PeriodicTaskIF*> pstTasks;
+  FixedTimeslotTaskIF* pst = factory->createFixedTimeslotTask(
+      "UART_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.5, missedDeadlineFunc);
+  result = pst::pstUart(pst);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+  }
+  pstTasks.push_back(pst);
+
+  PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask(
+      "PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = mpsocHelperTask->addComponent(objects::PLOC_MPSOC_HELPER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER);
+  }
+  pstTasks.push_back(mpsocHelperTask);
+
+  auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
+    for (const auto& task : taskVector) {
+      if (task != nullptr) {
+        task->startTask();
+      } else {
+        sif::error << "Task in vector " << name << " is invalid!" << std::endl;
+      }
+    }
+  };
+
+  sif::info << "Starting tasks.." << std::endl;
+  tmtcDistributor->startTask();
+  tmtcBridgeTask->startTask();
+  tmtcPollingTask->startTask();
+
+  taskStarter(pstTasks, "PST Tasks");
+  taskStarter(pusTasks, "PUS Tasks");
+
+  sif::info << "Tasks started.." << std::endl;
+}
+
+void initmission::createPusTasks(TaskFactory& factory,
+                                 TaskDeadlineMissedFunction missedDeadlineFunc,
+                                 std::vector<PeriodicTaskIF*>& taskVec) {
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
+      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "Object add component failed" << std::endl;
+  }
+  taskVec.push_back(pusVerification);
+
+  PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
+      "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
+  }
+  result = pusEvents->addComponent(objects::EVENT_MANAGER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
+  }
+  taskVec.push_back(pusEvents);
+
+  PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
+      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
+  }
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS9", objects::PUS_SERVICE_9_TIME_MGMT);
+  }
+  taskVec.push_back(pusHighPrio);
+
+  PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
+      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS8", objects::PUS_SERVICE_8_FUNCTION_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_200_MODE_MGMT);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS200", objects::PUS_SERVICE_200_MODE_MGMT);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_20_PARAMETERS);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS20", objects::PUS_SERVICE_20_PARAMETERS);
+  }
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS3", objects::PUS_SERVICE_3_HOUSEKEEPING);
+  }
+  taskVec.push_back(pusMedPrio);
+
+  PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
+      "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
+  result = pusLowPrio->addComponent(objects::PUS_SERVICE_17_TEST);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PUS17", objects::PUS_SERVICE_17_TEST);
+  }
+  result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("INT_ERR_RPRT", objects::INTERNAL_ERROR_REPORTER);
+  }
+  taskVec.push_back(pusLowPrio);
+}

bsp_te0720_1cfa/InitMission.h

@@ -0,0 +1,21 @@
+#ifndef BSP_LINUX_INITMISSION_H_
+#define BSP_LINUX_INITMISSION_H_
+
+#include <vector>
+
+#include "fsfw/tasks/Typedef.h"
+
+class PeriodicTaskIF;
+class TaskFactory;
+
+namespace initmission {
+void initMission();
+void initTasks();
+
+void createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                    std::vector<PeriodicTaskIF*>& taskVec);
+void createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction missedDeadlineFunc,
+                    std::vector<PeriodicTaskIF*>& taskVec);
+};  // namespace initmission
+
+#endif /* BSP_LINUX_INITMISSION_H_ */

bsp_te0720_1cfa/ObjectFactory.cpp

@@ -0,0 +1,152 @@
+#include "ObjectFactory.h"
+
+#include <devConf.h>
+#include "fsfw_hal/linux/uart/UartComIF.h"
+#include "fsfw_hal/linux/i2c/I2cComIF.h"
+#include "fsfw_hal/linux/uart/UartCookie.h"
+
+#include "OBSWConfig.h"
+#include "busConf.h"
+#include "devConf.h"
+#include "fsfw/datapoollocal/LocalDataPoolManager.h"
+#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"
+
+void Factory::setStaticFrameworkObjectIds() {
+  PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
+  PusServiceBase::packetDestination = objects::TM_FUNNEL;
+
+  CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
+  CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+
+  TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
+  TmFunnel::storageDestination = objects::NO_OBJECT;
+
+  VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
+  TmPacketBase::timeStamperId = objects::TIME_STAMPER;
+}
+
+void ObjectFactory::produce(void* args) {
+  Factory::setStaticFrameworkObjectIds();
+  ObjectFactory::produceGenericObjects();
+
+#if OBSW_ADD_PLOC_MPSOC == 1
+  UartCookie* mpsocUartCookie =
+      new UartCookie(objects::PLOC_MPSOC_HANDLER, te0720_1cfa::MPSOC_UART, UartModes::NON_CANONICAL,
+                     uart::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE);
+  mpsocUartCookie->setNoFixedSizeReply();
+  PlocMPSoCHelper* plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
+  new UartComIF(objects::UART_COM_IF);
+  auto dummyGpioIF = new DummyGpioIF();
+  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);
+}

bsp_te0720_1cfa/ObjectFactory.h

@@ -0,0 +1,8 @@
+#ifndef BSP_LINUX_OBJECTFACTORY_H_
+#define BSP_LINUX_OBJECTFACTORY_H_
+
+namespace ObjectFactory {
+void produce(void* args);
+};  // namespace ObjectFactory
+
+#endif /* BSP_LINUX_OBJECTFACTORY_H_ */

bsp_te0720_1cfa/boardconfig/CMakeLists.txt

@@ -0,0 +1,7 @@
+target_sources(${OBSW_NAME} PRIVATE
+	print.c
+)
+
+target_include_directories(${OBSW_NAME} PUBLIC
+	${CMAKE_CURRENT_SOURCE_DIR}
+)

bsp_te0720_1cfa/boardconfig/busConf.h

@@ -0,0 +1,11 @@
+#ifndef BSP_EGSE_BOARDCONFIG_BUSCONF_H_
+#define BSP_EGSE_BOARDCONFIG_BUSCONF_H_
+
+namespace te0720_1cfa {
+static constexpr char MPSOC_UART[] = "/dev/ttyPS1";
+namespace baudrate {
+
+}
+}
+
+#endif /* BSP_EGSE_BOARDCONFIG_BUSCONF_H_ */

bsp_te0720_1cfa/boardconfig/etl_profile.h

@@ -0,0 +1,38 @@
+///\file
+
+/******************************************************************************
+The MIT License(MIT)
+
+Embedded Template Library.
+https://github.com/ETLCPP/etl
+https://www.etlcpp.com
+
+Copyright(c) 2019 jwellbelove
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files(the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions :
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+******************************************************************************/
+#ifndef __ETL_PROFILE_H__
+#define __ETL_PROFILE_H__
+
+#define ETL_CHECK_PUSH_POP
+
+#define ETL_CPP11_SUPPORTED 1
+#define ETL_NO_NULLPTR_SUPPORT 0
+
+#endif

bsp_te0720_1cfa/boardconfig/gcov.h

@@ -0,0 +1,15 @@
+#ifndef LINUX_GCOV_H_
+#define LINUX_GCOV_H_
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+
+#ifdef GCOV
+extern "C" void __gcov_flush();
+#else
+void __gcov_flush() {
+  sif::info << "GCC GCOV: Please supply GCOV=1 in Makefile if "
+               "coverage information is desired.\n"
+            << std::flush;
+}
+#endif
+
+#endif /* LINUX_GCOV_H_ */

bsp_te0720_1cfa/boardconfig/print.c

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

bsp_te0720_1cfa/boardconfig/print.h

@@ -0,0 +1,8 @@
+#ifndef HOSTED_BOARDCONFIG_PRINT_H_
+#define HOSTED_BOARDCONFIG_PRINT_H_
+
+#include <stdbool.h>
+
+void printChar(const char* character, bool errStream);
+
+#endif /* HOSTED_BOARDCONFIG_PRINT_H_ */

bsp_te0720_1cfa/main.cpp

@@ -0,0 +1,29 @@
+#include <iostream>
+
+#include "InitMission.h"
+#include "OBSWConfig.h"
+#include "OBSWVersion.h"
+#include "fsfw/version.h"
+#include "fsfw/tasks/TaskFactory.h"
+
+/**
+ * @brief 	    This is the main program entry point for the obsw running on the trenz electronic
+ *              te0720-1cfa.
+ * @return
+ */
+int main(void) {
+  using namespace fsfw;
+  std::cout << "-- EIVE OBSW --" << std::endl;
+  std::cout << "-- Compiled for Trenz TE0720-1CFA"
+            << " --" << std::endl;
+  std::cout << "-- OBSW v" << SW_VERSION << "." << SW_SUBVERSION << "." << SW_REVISION << ", FSFW v"
+              << FSFW_VERSION << "--" << std::endl;
+  std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
+
+  initmission::initMission();
+
+  for (;;) {
+    /* Suspend main thread by sleeping it. */
+    TaskFactory::delayTask(5000);
+  }
+}

cmake/HardwareOsPreConfig.cmake

@@ -59,6 +59,8 @@ if(TGT_BSP)
 		set(BSP_PATH "bsp_q7s")
   elseif(TGT_BSP MATCHES "arm/egse")
     set(BSP_PATH "bsp_egse")
+  elseif(TGT_BSP MATCHES "arm/te0720-1cfa")
+    set(BSP_PATH "bsp_te0720_1cfa")
 	else() 
 		message(WARNING "CMake not configured for this target!")
 		message(FATAL_ERROR "Target: ${TGT_BSP}!")

cmake/PreProjectConfig.cmake

@@ -12,9 +12,9 @@ endif()
 
 # Disable compiler checks for cross-compiling.
 if(FSFW_OSAL MATCHES linux AND TGT_BSP)
-	if(TGT_BSP MATCHES "arm/q7s")
+	if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "arm/te0720-1cfa")
 		set(CMAKE_TOOLCHAIN_FILE 
-			"${CMAKE_SCRIPT_PATH}/Q7SCrossCompileConfig.cmake"
+			"${CMAKE_SCRIPT_PATH}/Zynq7020CrossCompileConfig.cmake"
 			PARENT_SCOPE
 		)
 	elseif(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/egse")

cmake/Zynq7020CrossCompileConfig.cmake

@@ -1,16 +1,16 @@
-if(DEFINED ENV{Q7S_SYSROOT})
+if(DEFINED ENV{ZYNQ_7020_SYSROOT})
-	set(ENV{Q7S_ROOTFS} $ENV{Q7S_SYSROOT})
+	set(ENV{ZYNQ_7020_ROOTFS} $ENV{ZYNQ_7020_SYSROOT})
 endif()
 # CROSS_COMPILE also needs to be set accordingly or passed to the CMake command
-if(NOT DEFINED ENV{Q7S_ROOTFS})
+if(NOT DEFINED ENV{ZYNQ_7020_ROOTFS})
     # Sysroot has not been cached yet and was not set in environment either
     if(NOT DEFINED SYSROOT_PATH)
         message(FATAL_ERROR 
-            "Define the Q7S_ROOTFS variable to point to the Q7S rootfs."
+            "Define the ZYNQ_7020_ROOTFS variable to point to the Zynq-7020 rootfs."
         )
     endif()
 else()
-	set(SYSROOT_PATH "$ENV{Q7S_ROOTFS}" CACHE PATH "Q7S root filesystem path")
+	set(SYSROOT_PATH "$ENV{ZYNQ_7020_ROOTFS}" CACHE PATH "Zynq-7020 root filesystem path")
 endif()
 
 if(NOT DEFINED ENV{CROSS_COMPILE})
@@ -87,18 +87,21 @@ set(C_FLAGS
     -mfloat-abi=hard
     ${COMMON_FLAGS}
     -lgpiod
-    -lxiphos
 )
 
+if (TGT_BSP MATCHES "arm/q7s")
+	set(C_FLAGS ${C_FLAGS} -lxiphos)
+endif()
+
 string (REPLACE ";" " " C_FLAGS "${C_FLAGS}")
 
 set(CMAKE_C_FLAGS 
     ${C_FLAGS}
-	CACHE STRING "C flags for Q7S"
+	CACHE STRING "C flags for Zynq-7020"
 )
 set(CMAKE_CXX_FLAGS 
 	"${CMAKE_C_FLAGS}"
-	CACHE STRING "CPP flags for Q7S"
+	CACHE STRING "CPP flags for Zynq-7020"
 )
 
 # search for programs in the build host directories

cmake/scripts/Q7S/q7s-env.sh

@@ -2,6 +2,6 @@
 export PATH=$PATH:"$HOME/EIVE/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin"
 export CROSS_COMPILE="arm-linux-gnueabihf"
 
-export Q7S_SYSROOT="$HOME/Xilinx/cortexa9hf-neon-xiphos-linux-gnueabi"
+export ZYNQ_7020_SYSROOT="$HOME/Xilinx/cortexa9hf-neon-xiphos-linux-gnueabi"
 export CONSOLE_PREFIX="[Q7S ENV]"
 /bin/bash

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

@@ -0,0 +1,49 @@
+#!/bin/sh
+# Run with: source win-q7s-env.sh [OPTIONS]
+function help () {
+	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"
+SYSROOT="/c/Users/${USER}/eive-software/cortexa9hf-neon-xiphos-linux-gnueabi"
+
+for i in "$@"; do
+  case $i in
+    -t=*|--toolchain=*)
+      TOOLCHAIN_PATH="${i#*=}"
+      shift
+      ;;
+    -s=*|--sysroot=*)
+      SYSROOT="${i#*=}"
+      shift
+      ;;
+	-h|--help)
+	  help
+	  shift
+      ;;
+    -*|--*)
+      echo "Unknown option $i"
+	  help
+      return
+      ;;
+    *)
+      ;;
+  esac
+done
+
+if [ -d "$TOOLCHAIN_PATH" ]; then
+	export PATH=$PATH:"/c/Xilinx/Vitis/2019.2/gnu/aarch32/nt/gcc-arm-linux-gnueabi/bin"
+	export CROSS_COMPILE="arm-linux-gnueabihf"
+	echo "Set toolchain path to /c/Xilinx/Vitis/2019.2/gnu/aarch32/nt/gcc-arm-linux-gnueabi/bin"
+else 
+	echo "Toolchain path $TOOLCHAIN_PATH does not exist"
+	return
+fi
+
+if [ -d "$SYSROOT" ]; then
+	export ZYNQ_7020_SYSROOT=$SYSROOT
+	echo "Set sysroot path to $SYSROOT"
+else 
+	echo "Sysroot path $SYSROOT does not exist"
+	return
+fi

cmake/scripts/cmake-build-cfg.py

@@ -12,6 +12,7 @@ import os
 import sys
 import argparse
 import shutil
+import stat
 
 
 def main():
@@ -102,7 +103,7 @@ def main():
             build_path = source_location + os.path.sep + build_folder
             remove_old_dir = False
         if remove_old_dir:
-            shutil.rmtree(build_path)
+            rm_build_dir(build_path)
     os.chdir(source_location)
     os.mkdir(build_folder)
     print(f"Navigating into build directory: {build_path}")
@@ -117,6 +118,14 @@ def main():
     print(f"\" {cmake_command} \"")
     os.system(cmake_command)
     print("-- CMake configuration done. --")
+    
+    
+def rm_build_dir(path: str):
+    # On windows the permissions of the build directory may have been set to read-only. If this
+    # is the case the permissions are changed before trying to delete the directory.
+    if not os.access(path, os.W_OK):
+        os.chmod(path, stat.S_IWUSR)
+    shutil.rmtree(path)
 
 
 def determine_source_location() -> str:

cmake/scripts/te0720-1cfa/make-debug-cfg.sh

@@ -0,0 +1,34 @@
+#!/bin/sh
+counter=0
+cfg_script_name="cmake-build-cfg.py"
+while [ ${counter} -lt 5 ]
+do
+    cd ..
+    if [ -f ${cfg_script_name} ];then
+        break
+    fi
+    counter=$((counter=counter + 1))
+done
+
+if [ "${counter}" -ge 5 ];then
+    echo "${cfg_script_name} not found in upper directories!"
+    exit 1
+fi
+
+
+os_fsfw="linux"
+tgt_bsp="arm/te0720-1cfa"
+build_generator="make"
+build_dir="build-Debug-te0720-1cfa"
+if [ "${OS}" = "Windows_NT" ]; then
+    python="py"
+# Could be other OS but this works for now.
+else
+    python="python3"
+fi
+
+echo "Running command (without the leading +):"
+set -x # Print command 
+${python} ${cfg_script_name} -o "${os_fsfw}" -g "${build_generator}" -b "debug" -t "${tgt_bsp}" \
+	-l"${build_dir}"
+# set +x

cmake/scripts/te0720-1cfa/win-env-te0720-1cfa.sh

@@ -5,7 +5,7 @@ function help () {
 }
 
 TOOLCHAIN_PATH="/c/Xilinx/Vitis/2019.2/gnu/aarch32/nt/gcc-arm-linux-gnueabi/bin"
-SYSROOT="/c/Users/${USER}/eive-software/cortexa9hf-neon-xiphos-linux-gnueabi"
+SYSROOT="/c/Users/${USER}/eive-software/sysroots-petalinux-2019-2/cortexa9t2hf-neon-xilinx-linux-gnueabi"
 
 for i in "$@"; do
   case $i in
@@ -41,7 +41,7 @@ else
 fi
 
 if [ -d "$SYSROOT" ]; then
-	export Q7S_SYSROOT=$SYSROOT
+	export ZYNQ_7020_SYSROOT=$SYSROOT
 	echo "Set sysroot path to $SYSROOT"
 else 
 	echo "Sysroot path $SYSROOT does not exist"

common/config/commonClassIds.h

@@ -13,7 +13,8 @@ enum commonClassIds: uint8_t {
 	IMTQ_HANDLER, //IMTQ
 	RW_HANDLER, //RWHA
 	STR_HANDLER, //STRH
-	PLOC_MPSOC_HANDLER, //PLMP
+	DWLPWRON_CMD, //DWLPWRON
+	MPSOC_TM, //MPTM
 	PLOC_SUPERVISOR_HANDLER, //PLSV
 	SUS_HANDLER, //SUSS
 	CCSDS_IP_CORE_BRIDGE, //IPCI
@@ -27,7 +28,10 @@ enum commonClassIds: uint8_t {
     RATE_SETTER, //RS
     ARCSEC_JSON_BASE, //JSONBASE
     NVM_PARAM_BASE, //NVMB
+    FILE_SYSTEM_HELPER, //FSHLP
+    PLOC_MPSOC_HELPER, // PLMPHLP
 	SA_DEPL_HANDLER, //SADPL
+	MPSOC_RETURN_VALUES_IF, //MPSOCRTVIF
 	COMMON_CLASS_ID_END // [EXPORT] : [END]
 };
 

common/config/commonObjects.h

@@ -42,6 +42,7 @@ enum commonObjects: uint32_t {
     IMTQ_HANDLER = 0x44140014,
     PLOC_MPSOC_HANDLER = 0x44330015,
     PLOC_SUPERVISOR_HANDLER = 0x44330016,
+    PLOC_SUPERVISOR_HELPER = 0x44330017,
 
     /**
      * Not yet specified which pt1000 will measure which device/location in the satellite.
@@ -89,8 +90,9 @@ enum commonObjects: uint32_t {
     PLOC_UPDATER = 0x44330000,
     PLOC_MEMORY_DUMPER = 0x44330001,
     STR_HELPER = 0x44330002,
-    AXI_PTME_CONFIG = 44330003,
+    PLOC_MPSOC_HELPER = 0x44330003,
-    PTME_CONFIG = 44330004,
+    AXI_PTME_CONFIG = 44330004,
+    PTME_CONFIG = 44330005,
 
     // 0x73 ('s') for assemblies and system/subsystem components
     ACS_BOARD_ASS = 0x73000001,

common/config/commonSubsystemIds.h

@@ -19,10 +19,11 @@ enum: uint8_t {
 	PLOC_MEMORY_DUMPER = 118,
 	PDEC_HANDLER = 119,
 	STR_HELPER = 120,
-	PL_PCDU_HANDLER = 121,
+	PLOC_MPSOC_HELPER = 121,
-	ACS_BOARD_ASS = 122,
+	PL_PCDU_HANDLER = 122,
-	SUS_BOARD_ASS = 123,
+	ACS_BOARD_ASS = 123,
-	TCS_BOARD_ASS = 124,
+	SUS_BOARD_ASS = 124,
+	TCS_BOARD_ASS = 125,
 	COMMON_SUBSYSTEM_ID_END
 };
 }

common/config/devConf.h

@@ -51,7 +51,7 @@ namespace uart {
 static constexpr size_t HYPERION_GPS_REPLY_MAX_BUFFER = 1024;
 static constexpr uint32_t SYRLINKS_BAUD = 38400;
 static constexpr uint32_t GNSS_BAUD = 9600;
-static constexpr uint32_t PLOC_MPSOC_BAUD = 921600;
+static constexpr uint32_t PLOC_MPSOC_BAUD = 115200;
 static constexpr uint32_t PLOC_SUPERVISOR_BAUD = 115200;
 static constexpr uint32_t STAR_TRACKER_BAUD = 921600;
 

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

@@ -15,6 +15,10 @@ 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;
+
 }
 
 

fsfw

@@ -1 +1 @@
-Subproject commit 6ea1eabb2dd3688f2c7db484cd141f15c9f4fe49
+Subproject commit 283a37dccc064b71a0e4ca5c483c9a5a5241d355

generators/bsp_q7s_events.csv

@@ -90,10 +90,11 @@
 11002;0x2afa;DEPLOYMENT_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
 11003;0x2afb;DEPL_SA1_GPIO_SWTICH_ON_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
 11004;0x2afc;DEPL_SA2_GPIO_SWTICH_ON_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
-11101;0x2b5d;MEMORY_READ_RPT_CRC_FAILURE;LOW;;mission/devices/PlocMPSoCHandler.h
+11101;0x2b5d;MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC crc failure in telemetry packet;linux/devices/ploc/PlocMPSoCHandler.h
-11102;0x2b5e;ACK_FAILURE;LOW;;mission/devices/PlocMPSoCHandler.h
+11102;0x2b5e;ACK_FAILURE;LOW;PLOC receive acknowledgment failure report P1: Command Id which leads the acknowledgment failure report P2: The status field inserted by the MPSoC into the data field;linux/devices/ploc/PlocMPSoCHandler.h
-11103;0x2b5f;EXE_FAILURE;LOW;;mission/devices/PlocMPSoCHandler.h
+11103;0x2b5f;EXE_FAILURE;LOW;PLOC receive execution failure report P1: Command Id which leads the execution failure report P2: The status field inserted by the MPSoC into the data field;linux/devices/ploc/PlocMPSoCHandler.h
-11104;0x2b60;CRC_FAILURE_EVENT;LOW;;mission/devices/PlocMPSoCHandler.h
+11104;0x2b60;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/devices/ploc/PlocMPSoCHandler.h
+11105;0x2b61;MPSOC_HANDLER_SEQ_CNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/devices/ploc/PlocMPSoCHandler.h
 11201;0x2bc1;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h
 11202;0x2bc2;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h
 11203;0x2bc3;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h
@@ -105,21 +106,21 @@
 11301;0x2c25;ERROR_STATE;HIGH;Reaction wheel signals an error state;mission/devices/RwHandler.h
 11401;0x2c89;BOOTING_FIRMWARE_FAILED;LOW;Failed to boot firmware;linux/devices/startracker/StarTrackerHandler.h
 11402;0x2c8a;BOOTING_BOOTLOADER_FAILED;LOW;Failed to boot star tracker into bootloader mode;linux/devices/startracker/StarTrackerHandler.h
-11501;0x2ced;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;bsp_q7s/devices/PlocSupervisorHandler.h
+11501;0x2ced;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/devices/ploc/PlocSupervisorHandler.h
-11502;0x2cee;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;bsp_q7s/devices/PlocSupervisorHandler.h
+11502;0x2cee;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/devices/ploc/PlocSupervisorHandler.h
-11503;0x2cef;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report;bsp_q7s/devices/PlocSupervisorHandler.h
+11503;0x2cef;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report;linux/devices/ploc/PlocSupervisorHandler.h
-11504;0x2cf0;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;bsp_q7s/devices/PlocSupervisorHandler.h
+11504;0x2cf0;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/devices/ploc/PlocSupervisorHandler.h
 11600;0x2d50;SANITIZATION_FAILED;LOW;;bsp_q7s/memory/SdCardManager.h
 11601;0x2d51;MOUNTED_SD_CARD;INFO;;bsp_q7s/memory/SdCardManager.h
-11700;0x2db4;UPDATE_FILE_NOT_EXISTS;LOW;;bsp_q7s/devices/PlocUpdater.h
+11700;0x2db4;UPDATE_FILE_NOT_EXISTS;LOW;;linux/devices/ploc/PlocUpdater.h
-11701;0x2db5;ACTION_COMMANDING_FAILED;LOW;Failed to send command to supervisor handler P1: Return value of CommandActionHelper::commandAction P2: Action ID of command to send;bsp_q7s/devices/PlocUpdater.h
+11701;0x2db5;ACTION_COMMANDING_FAILED;LOW;Failed to send command to supervisor handler P1: Return value of CommandActionHelper::commandAction P2: Action ID of command to send;linux/devices/ploc/PlocUpdater.h
-11702;0x2db6;UPDATE_AVAILABLE_FAILED;LOW;Supervisor handler replied action message indicating a command execution failure of the update available command;bsp_q7s/devices/PlocUpdater.h
+11702;0x2db6;UPDATE_AVAILABLE_FAILED;LOW;Supervisor handler replied action message indicating a command execution failure of the update available command;linux/devices/ploc/PlocUpdater.h
-11703;0x2db7;UPDATE_TRANSFER_FAILED;LOW;Supervisor handler failed to transfer an update space packet. P1: Parameter holds the number of update packets already sent (inclusive the failed packet);bsp_q7s/devices/PlocUpdater.h
+11703;0x2db7;UPDATE_TRANSFER_FAILED;LOW;Supervisor handler failed to transfer an update space packet. P1: Parameter holds the number of update packets already sent (inclusive the failed packet);linux/devices/ploc/PlocUpdater.h
-11704;0x2db8;UPDATE_VERIFY_FAILED;LOW;Supervisor failed to execute the update verify command.;bsp_q7s/devices/PlocUpdater.h
+11704;0x2db8;UPDATE_VERIFY_FAILED;LOW;Supervisor failed to execute the update verify command.;linux/devices/ploc/PlocUpdater.h
-11705;0x2db9;UPDATE_FINISHED;INFO;MPSoC update successful completed;bsp_q7s/devices/PlocUpdater.h
+11705;0x2db9;UPDATE_FINISHED;INFO;MPSoC update successful completed;linux/devices/ploc/PlocUpdater.h
-11800;0x2e18;SEND_MRAM_DUMP_FAILED;LOW;Failed to send mram dump command to supervisor handler P1: Return value of commandAction function P2: Start address of MRAM to dump with this command;bsp_q7s/devices/PlocMemoryDumper.h
+11800;0x2e18;SEND_MRAM_DUMP_FAILED;LOW;Failed to send mram dump command to supervisor handler P1: Return value of commandAction function P2: Start address of MRAM to dump with this command;linux/devices/ploc/PlocMemoryDumper.h
-11801;0x2e19;MRAM_DUMP_FAILED;LOW;Received completion failure report form PLOC supervisor handler P1: MRAM start address of failing dump command;bsp_q7s/devices/PlocMemoryDumper.h
+11801;0x2e19;MRAM_DUMP_FAILED;LOW;Received completion failure report form PLOC supervisor handler P1: MRAM start address of failing dump command;linux/devices/ploc/PlocMemoryDumper.h
-11802;0x2e1a;MRAM_DUMP_FINISHED;LOW;MRAM dump finished successfully;bsp_q7s/devices/PlocMemoryDumper.h
+11802;0x2e1a;MRAM_DUMP_FINISHED;LOW;MRAM dump finished successfully;linux/devices/ploc/PlocMemoryDumper.h
 11901;0x2e7d;INVALID_TC_FRAME;HIGH;;linux/obc/PdecHandler.h
 11902;0x2e7e;INVALID_FAR;HIGH;Read invalid FAR from PDEC after startup;linux/obc/PdecHandler.h
 11903;0x2e7f;CARRIER_LOCK;INFO;Carrier lock detected;linux/obc/PdecHandler.h
@@ -141,27 +142,39 @@
 12014;0x2eee;STR_HELPER_FILE_NOT_EXISTS;LOW;Specified file does not exist P1: Internal state of str helper;linux/devices/startracker/StrHelper.h
 12015;0x2eef;STR_HELPER_SENDING_PACKET_FAILED;LOW;;linux/devices/startracker/StrHelper.h
 12016;0x2ef0;STR_HELPER_REQUESTING_MSG_FAILED;LOW;;linux/devices/startracker/StrHelper.h
-12100;0x2f44;TRANSITION_BACK_TO_OFF;MEDIUM;Could not transition properly and went back to ALL OFF;mission/devices/PayloadPcduHandler.h
+12100;0x2f44;MPSOC_FLASH_WRITE_FAILED;LOW;Flash write fails;linux/devices/ploc/PlocMPSoCHelper.h
-12101;0x2f45;NEG_V_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
+12101;0x2f45;MPSOC_FLASH_WRITE_SUCCESSFUL;LOW;Flash write successful;linux/devices/ploc/PlocMPSoCHelper.h
-12102;0x2f46;U_DRO_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
+12102;0x2f46;SENDING_COMMAND_FAILED;LOW;;linux/devices/ploc/PlocMPSoCHelper.h
-12103;0x2f47;I_DRO_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.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;U_X8_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.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;I_X8_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.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;U_TX_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.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;I_TX_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
+12107;0x2f4b;ACK_FAILURE_REPORT;LOW;Received acknowledgement failure report P1: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h
-12108;0x2f4c;U_MPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
+12108;0x2f4c;EXE_FAILURE_REPORT;LOW;Received execution failure report P1: Internal state of MPSoC;linux/devices/ploc/PlocMPSoCHelper.h
-12109;0x2f4d;I_MPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.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;U_HPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.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;I_HPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.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
+12200;0x2fa8;TRANSITION_BACK_TO_OFF;MEDIUM;Could not transition properly and went back to ALL OFF;mission/devices/PayloadPcduHandler.h
-12201;0x2fa9;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/AcsBoardAssembly.h
+12201;0x2fa9;NEG_V_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
-12202;0x2faa;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/AcsBoardAssembly.h
+12202;0x2faa;U_DRO_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
-12203;0x2fab;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/AcsBoardAssembly.h
+12203;0x2fab;I_DRO_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
-12300;0x300c;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/SusAssembly.h
+12204;0x2fac;U_X8_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
-12301;0x300d;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/SusAssembly.h
+12205;0x2fad;I_X8_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
-12302;0x300e;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/SusAssembly.h
+12206;0x2fae;U_TX_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
-12303;0x300f;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/SusAssembly.h
+12207;0x2faf;I_TX_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
-12400;0x3070;CHILDREN_LOST_MODE;MEDIUM;;mission/system/TcsBoardAssembly.h
+12208;0x2fb0;U_MPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
+12209;0x2fb1;I_MPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
+12210;0x2fb2;U_HPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
+12211;0x2fb3;I_HPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
+12300;0x300c;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/AcsBoardAssembly.h
+12301;0x300d;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/AcsBoardAssembly.h
+12302;0x300e;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/AcsBoardAssembly.h
+12303;0x300f;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/AcsBoardAssembly.h
+12400;0x3070;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/SusAssembly.h
+12401;0x3071;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/SusAssembly.h
+12402;0x3072;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/SusAssembly.h
+12403;0x3073;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/SusAssembly.h
+12500;0x30d4;CHILDREN_LOST_MODE;MEDIUM;;mission/system/TcsBoardAssembly.h
 13600;0x3520;ALLOC_FAILURE;MEDIUM;;bsp_q7s/core/CoreController.h
 13601;0x3521;REBOOT_SW;MEDIUM; Software reboot occured. Can also be a systemd reboot. P1: Current Chip, P2: Current Copy;bsp_q7s/core/CoreController.h
 13602;0x3522;REBOOT_MECHANISM_TRIGGERED;MEDIUM;The reboot mechanism was triggered. P1: First 16 bits: Last Chip, Last 16 bits: Last Copy, P2: Each byte is the respective reboot count for the slots;bsp_q7s/core/CoreController.h

generators/bsp_q7s_objects.csv

@@ -40,8 +40,10 @@
 0x44330000;PLOC_UPDATER
 0x44330001;PLOC_MEMORY_DUMPER
 0x44330002;STR_HELPER
+0x44330003;PLOC_MPSOC_HELPER
 0x44330015;PLOC_MPSOC_HANDLER
 0x44330016;PLOC_SUPERVISOR_HANDLER
+0x44330017;PLOC_SUPERVISOR_HELPER
 0x444100A2;SOLAR_ARRAY_DEPL_HANDLER
 0x444100A4;HEATER_HANDLER
 0x44420004;TMP1075_HANDLER_1

generators/bsp_q7s_returnvalues.csv

@@ -1,12 +1,13 @@
 0x0;OK;System-wide code for ok.;RETURN_OK;HasReturnvaluesIF.h;HasReturnvaluesIF
 0x1;Failed;Unspecified system-wide code for failed.;RETURN_FAILED;HasReturnvaluesIF.h;HasReturnvaluesIF
-0x61a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;0xA0;mission/tmtc/CCSDSHandler.h;CCSDS_HANDLER
+0x62a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;0xA0;mission/tmtc/CCSDSHandler.h;CCSDS_HANDLER
-0x5e00;GOMS_PacketTooLong;;0;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
+0x68a0;SADPL_CommandNotSupported;;0xA0;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
-0x5e01;GOMS_InvalidTableId;;1;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
+0x68a1;SADPL_DeploymentAlreadyExecuting;;0xA1;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
-0x5e02;GOMS_InvalidAddress;;2;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
+0x68a2;SADPL_MainSwitchTimeoutFailure;;0xA2;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
-0x5e03;GOMS_InvalidParamSize;;3;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
+0x68a3;SADPL_SwitchingDeplSa1Failed;;0xA3;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
-0x5e04;GOMS_InvalidPayloadSize;;4;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
+0x68a4;SADPL_SwitchingDeplSa2Failed;;0xA4;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
-0x5e05;GOMS_UnknownReplyId;;5;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
+0x5aa0;SUSS_ErrorUnlockMutex;;0xA0;mission/devices/SusHandler.h;SUS_HANDLER
+0x5aa1;SUSS_ErrorLockMutex;;0xA1;mission/devices/SusHandler.h;SUS_HANDLER
 0x55b0;RWHA_SpiWriteFailure;;0xB0;mission/devices/RwHandler.h;RW_HANDLER
 0x55b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;0xB1;mission/devices/RwHandler.h;RW_HANDLER
 0x55b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;0xB2;mission/devices/RwHandler.h;RW_HANDLER
@@ -19,13 +20,6 @@
 0x55a2;RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;0xA2;mission/devices/RwHandler.h;RW_HANDLER
 0x55a3;RWHA_ExecutionFailed;Command execution failed;0xA3;mission/devices/RwHandler.h;RW_HANDLER
 0x55a4;RWHA_CrcError;Reaction wheel reply has invalid crc;0xA4;mission/devices/RwHandler.h;RW_HANDLER
-0x52a1;HEATER_CommandNotSupported;;0xA1;mission/devices/HeaterHandler.h;HEATER_HANDLER
-0x52a2;HEATER_InitFailed;;0xA2;mission/devices/HeaterHandler.h;HEATER_HANDLER
-0x52a3;HEATER_InvalidSwitchNr;;0xA3;mission/devices/HeaterHandler.h;HEATER_HANDLER
-0x52a4;HEATER_MainSwitchSetTimeout;;0xA4;mission/devices/HeaterHandler.h;HEATER_HANDLER
-0x52a5;HEATER_CommandAlreadyWaiting;;0xA5;mission/devices/HeaterHandler.h;HEATER_HANDLER
-0x59a0;SUSS_ErrorUnlockMutex;;0xA0;mission/devices/SusHandler.h;SUS_HANDLER
-0x59a1;SUSS_ErrorLockMutex;;0xA1;mission/devices/SusHandler.h;SUS_HANDLER
 0x54a0;IMTQ_InvalidCommandCode;;0xA0;mission/devices/IMTQHandler.h;IMTQ_HANDLER
 0x54a1;IMTQ_ParameterMissing;;0xA1;mission/devices/IMTQHandler.h;IMTQ_HANDLER
 0x54a2;IMTQ_ParameterInvalid;;0xA2;mission/devices/IMTQHandler.h;IMTQ_HANDLER
@@ -34,6 +28,17 @@
 0x54a5;IMTQ_RejectedWithoutReason;;0xA5;mission/devices/IMTQHandler.h;IMTQ_HANDLER
 0x54a6;IMTQ_CmdErrUnknown;;0xA6;mission/devices/IMTQHandler.h;IMTQ_HANDLER
 0x54a7;IMTQ_UnexpectedSelfTestReply;The status reply to a self test command was received but no self test command has been sent. This should normally never happen.;0xA7;mission/devices/IMTQHandler.h;IMTQ_HANDLER
+0x52a1;HEATER_CommandNotSupported;;0xA1;mission/devices/HeaterHandler.h;HEATER_HANDLER
+0x52a2;HEATER_InitFailed;;0xA2;mission/devices/HeaterHandler.h;HEATER_HANDLER
+0x52a3;HEATER_InvalidSwitchNr;;0xA3;mission/devices/HeaterHandler.h;HEATER_HANDLER
+0x52a4;HEATER_MainSwitchSetTimeout;;0xA4;mission/devices/HeaterHandler.h;HEATER_HANDLER
+0x52a5;HEATER_CommandAlreadyWaiting;;0xA5;mission/devices/HeaterHandler.h;HEATER_HANDLER
+0x5f00;GOMS_PacketTooLong;;0;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
+0x5f01;GOMS_InvalidTableId;;1;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
+0x5f02;GOMS_InvalidAddress;;2;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
+0x5f03;GOMS_InvalidParamSize;;3;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
+0x5f04;GOMS_InvalidPayloadSize;;4;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
+0x5f05;GOMS_UnknownReplyId;;5;mission/devices/GomspaceDeviceHandler.h;GOM_SPACE_HANDLER
 0x53a0;SYRLINKS_CrcFailure;;0xA0;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
 0x53a1;SYRLINKS_UartFraminOrParityErrorAck;;0xA1;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
 0x53a2;SYRLINKS_BadCharacterAck;;0xA2;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
@@ -43,19 +48,10 @@
 0x53a6;SYRLINKS_BadCrcAck;;0xA6;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
 0x53a7;SYRLINKS_ReplyWrongSize;;0xA7;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
 0x53a8;SYRLINKS_MissingStartFrameCharacter;;0xA8;mission/devices/SyrlinksHkHandler.h;SYRLINKS_HANDLER
-0x65a0;SADPL_CommandNotSupported;;0xA0;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
+0x65a0;NVMB_KeyNotExists;Specified key does not exist in json file;0xA0;mission/memory/NVMParameterBase.h;NVM_PARAM_BASE
-0x65a1;SADPL_DeploymentAlreadyExecuting;;0xA1;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
+0x4300; HSPI_OpeningFileFailed;;0;fsfw/hal/src/fsfw_hal/linux/spi/SpiComIF.h;HAL_SPI
-0x65a2;SADPL_MainSwitchTimeoutFailure;;0xA2;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
+0x4301; HSPI_FullDuplexTransferFailed;;1;fsfw/hal/src/fsfw_hal/linux/spi/SpiComIF.h;HAL_SPI
-0x65a3;SADPL_SwitchingDeplSa1Failed;;0xA3;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
+0x4302; HSPI_HalfDuplexTransferFailed;;2;fsfw/hal/src/fsfw_hal/linux/spi/SpiComIF.h;HAL_SPI
-0x65a4;SADPL_SwitchingDeplSa2Failed;;0xA4;mission/devices/SolarArrayDeploymentHandler.h;SA_DEPL_HANDLER
-0x57a0;PLMP_CrcFailure;;0xA0;mission/devices/PlocMPSoCHandler.h;PLOC_MPSOC_HANDLER
-0x57a1;PLMP_ReceivedAckFailure;;0xA1;mission/devices/PlocMPSoCHandler.h;PLOC_MPSOC_HANDLER
-0x57a2;PLMP_ReceivedExeFailure;;0xA2;mission/devices/PlocMPSoCHandler.h;PLOC_MPSOC_HANDLER
-0x57a3;PLMP_InvalidApid;;0xA3;mission/devices/PlocMPSoCHandler.h;PLOC_MPSOC_HANDLER
-0x64a0;NVMB_KeyNotExists;Specified key does not exist in json file;0xA0;mission/memory/NVMParameterBase.h;NVM_PARAM_BASE
-0x4300; HSPI_HalTimeoutRetval;;0;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h;HAL_SPI
-0x4301; HSPI_HalBusyRetval;;1;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h;HAL_SPI
-0x4302; HSPI_HalErrorRetval;;2;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h;HAL_SPI
 0x4401; HURT_UartReadFailure;;1;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h;HAL_UART
 0x4402; HURT_UartReadSizeMissmatch;;2;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h;HAL_UART
 0x4403; HURT_UartRxBufferTooSmall;;3;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h;HAL_UART
@@ -70,36 +66,119 @@
 0x4203; UXOS_CommandError;Command execution failed;3;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h;LINUX_OSAL
 0x4204; UXOS_NoCommandLoadedOrPending;;4;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h;LINUX_OSAL
 0x4206; UXOS_PcloseCallError;;6;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h;LINUX_OSAL
-0x2b01; CCS_BcIsSetVrCommand;;0x01;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3b00; LPIF_PoolEntryNotFound;;0x00;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h;LOCAL_POOL_OWNER_IF
-0x2b02; CCS_BcIsUnlockCommand;;0x02;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3b01; LPIF_PoolEntryTypeConflict;;0x01;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h;LOCAL_POOL_OWNER_IF
-0x2bb0; CCS_BcIllegalCommand;;0xB0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3d00; HKM_QueueOrDestinationInvalid;;0;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x2bb1; CCS_BoardReadingNotFinished;;0xB1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3d01; HKM_WrongHkPacketType;;1;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x2bf0; CCS_NsPositiveW;;0xF0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3d02; HKM_ReportingStatusUnchanged;;2;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x2bf1; CCS_NsNegativeW;;0xF1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3d03; HKM_PeriodicHelperInvalid;;3;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x2bf2; CCS_NsLockout;;0xF2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3d04; HKM_PoolobjectNotFound;;4;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x2bf3; CCS_FarmInLockout;;0xF3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3d05; HKM_DatasetNotFound;;5;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x2bf4; CCS_FarmInWait;;0xF4;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3501; CFDP_InvalidTlvType;;1;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x2be0; CCS_WrongSymbol;;0xE0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3502; CFDP_InvalidDirectiveFields;;2;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x2be1; CCS_DoubleStart;;0xE1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3503; CFDP_InvalidPduDatafieldLen;;3;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x2be2; CCS_StartSymbolMissed;;0xE2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3504; CFDP_InvalidAckDirectiveFields;;4;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x2be3; CCS_EndWithoutStart;;0xE3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3505; CFDP_MetadataCantParseOptions;;5;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x2be4; CCS_TooLarge;;0xE4;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3506; CFDP_FinishedCantParseFsResponses;;6;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x2be5; CCS_TooShort;;0xE5;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3508; CFDP_FilestoreRequiresSecondFile;;8;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x2be6; CCS_WrongTfVersion;;0xE6;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3509; CFDP_FilestoreResponseCantParseFsMessage;;9;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x2be7; CCS_WrongSpacecraftId;;0xE7;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3101; CF_ObjectHasNoFunctions;;1;fsfw/src/fsfw/action/CommandsActionsIF.h;COMMANDS_ACTIONS_IF
-0x2be8; CCS_NoValidFrameType;;0xE8;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3102; CF_AlreadyCommanding;;2;fsfw/src/fsfw/action/CommandsActionsIF.h;COMMANDS_ACTIONS_IF
-0x2be9; CCS_CrcFailed;;0xE9;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3201; HF_IsBusy;;1;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
-0x2bea; CCS_VcNotFound;;0xEA;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3202; HF_InvalidParameters;;2;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
-0x2beb; CCS_ForwardingFailed;;0xEB;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3203; HF_ExecutionFinished;;3;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
-0x2bec; CCS_ContentTooLarge;;0xEC;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x3204; HF_InvalidActionId;;4;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
-0x2bed; CCS_ResidualData;;0xED;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2d01; HPA_InvalidIdentifierId;;0x01;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
-0x2bee; CCS_DataCorrupted;;0xEE;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2d02; HPA_InvalidDomainId;;0x02;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
-0x2bef; CCS_IllegalSegmentationFlag;;0xEF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2d03; HPA_InvalidValue;;0x03;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
-0x2bd0; CCS_IllegalFlagCombination;;0xD0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2d05; HPA_ReadOnly;;0x05;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
-0x2bd1; CCS_ShorterThanHeader;;0xD1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2c01; PAW_UnknownDatatype;;0x01;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
-0x2bd2; CCS_TooShortBlockedPacket;;0xD2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2c02; PAW_DatatypeMissmatch;;0x02;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
-0x2bd3; CCS_TooShortMapExtraction;;0xD3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2c03; PAW_Readonly;;0x03;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
-0x3a00; SPH_ConnBroken;;0;fsfw/src/fsfw/osal/common/TcpTmTcServer.h;SEMAPHORE_IF
+0x2c04; PAW_TooBig;;0x04;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x2c05; PAW_SourceNotSet;;0x05;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x2c06; PAW_OutOfBounds;;0x06;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x2c07; PAW_NotSet;;0x07;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x2c08; PAW_ColumnOrRowsZero;;0x08;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x1701; HHI_ObjectNotHealthy;;1;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF
+0x1702; HHI_InvalidHealthState;;2;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF
+0x2701; SM_DataTooLarge;;1;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
+0x2702; SM_DataStorageFull;;2;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
+0x2703; SM_IllegalStorageId;;3;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
+0x2704; SM_DataDoesNotExist;;4;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
+0x2705; SM_IllegalAddress;;5;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
+0x2706; SM_PoolTooLarge;;6;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
+0x2301; MT_TooDetailedRequest;;1;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS
+0x2302; MT_TooGeneralRequest;;2;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS
+0x2303; MT_NoMatch;;3;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS
+0x2304; MT_Full;;4;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS
+0x2305; MT_NewNodeCreated;;5;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS
+0x3e01; DLEE_StreamTooShort;;0x01;fsfw/src/fsfw/globalfunctions/DleEncoder.h;DLE_ENCODER
+0x3e02; DLEE_DecodingError;;0x02;fsfw/src/fsfw/globalfunctions/DleEncoder.h;DLE_ENCODER
+0x2e01; ASC_TooLongForTargetType;;1;fsfw/src/fsfw/globalfunctions/AsciiConverter.h;ASCII_CONVERTER
+0x2e02; ASC_InvalidCharacters;;2;fsfw/src/fsfw/globalfunctions/AsciiConverter.h;ASCII_CONVERTER
+0x2e03; ASC_BufferTooSmall;;0x3;fsfw/src/fsfw/globalfunctions/AsciiConverter.h;ASCII_CONVERTER
+0x1c01; TCD_PacketLost;;1;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION
+0x1c02; TCD_DestinationNotFound;;2;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION
+0x1c03; TCD_ServiceIdAlreadyExists;;3;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION
+0x1b00; TCC_IllegalApid;;0;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x1b01; TCC_IncompletePacket;;1;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x1b02; TCC_IncorrectChecksum;;2;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x1b03; TCC_IllegalPacketType;;3;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x1b04; TCC_IllegalPacketSubtype;;4;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x1b05; TCC_IncorrectPrimaryHeader;;5;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x1b06; TCC_IncorrectSecondaryHeader;;6;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
+0x3901; MQI_Empty;;1;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF
+0x3902; MQI_Full;No space left for more messages;2;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF
+0x3903; MQI_NoReplyPartner;Returned if a reply method was called without partner;3;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF
+0x3904; MQI_DestinationInvalid;Returned if the target destination is invalid.;4;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF
+0xf01; CM_UnknownCommand;;1;fsfw/src/fsfw/ipc/CommandMessageIF.h;COMMAND_MESSAGE
+0x3801; MUX_NotEnoughResources;;1;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
+0x3802; MUX_InsufficientMemory;;2;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
+0x3803; MUX_NoPrivilege;;3;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
+0x3804; MUX_WrongAttributeSetting;;4;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
+0x3805; MUX_MutexAlreadyLocked;;5;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
+0x3806; MUX_MutexNotFound;;6;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
+0x3807; MUX_MutexMaxLocks;;7;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
+0x3808; MUX_CurrThreadAlreadyOwnsMutex;;8;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
+0x3809; MUX_CurrThreadDoesNotOwnMutex;;9;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
+0x380a; MUX_MutexTimeout;;10;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
+0x380b; MUX_MutexInvalidId;;11;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
+0x380c; MUX_MutexDestroyedWhileWaiting;;12;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
+0x2801; TC_InvalidTargetState;;1;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF
+0x28f1; TC_AboveOperationalLimit;;0xF1;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF
+0x28f2; TC_BelowOperationalLimit;;0xF2;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF
+0x801; DPS_InvalidParameterDefinition;;1;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
+0x802; DPS_SetWasAlreadyRead;;2;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
+0x803; DPS_CommitingWithoutReading;;3;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
+0x804; DPS_DataSetUninitialised;;4;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
+0x805; DPS_DataSetFull;;5;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
+0x806; DPS_PoolVarNull;;6;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
+0x3ca0; PVA_InvalidReadWriteMode;;0xA0;fsfw/src/fsfw/datapool/PoolVariableIF.h;POOL_VARIABLE_IF
+0x3ca1; PVA_InvalidPoolEntry;;0xA1;fsfw/src/fsfw/datapool/PoolVariableIF.h;POOL_VARIABLE_IF
+0xc02; MS_InvalidEntry;;0x02;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF
+0xc03; MS_TooManyElements;;0x03;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF
+0xc04; MS_CantStoreEmpty;;0x04;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF
+0xd01; SS_SequenceAlreadyExists;;0x01;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xd02; SS_TableAlreadyExists;;0x02;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xd03; SS_TableDoesNotExist;;0x03;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xd04; SS_TableOrSequenceLengthInvalid;;0x04;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xd05; SS_SequenceDoesNotExist;;0x05;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xd06; SS_TableContainsInvalidObjectId;;0x06;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xd07; SS_FallbackSequenceDoesNotExist;;0x07;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xd08; SS_NoTargetTable;;0x08;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xd09; SS_SequenceOrTableTooLong;;0x09;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xd0b; SS_IsFallbackSequence;;0x0B;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xd0c; SS_AccessDenied;;0x0C;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xd0e; SS_TableInUse;;0x0E;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xda1; SS_TargetTableNotReached;;0xA1;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xda2; SS_TableCheckFailed;;0xA2;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
+0xb01; SB_ChildNotFound;;0x01;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE
+0xb02; SB_ChildInfoUpdated;;0x02;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE
+0xb03; SB_ChildDoesntHaveModes;;0x03;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE
+0xb04; SB_CouldNotInsertChild;;0x04;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE
+0xb05; SB_TableContainsInvalidObjectId;;0x05;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE
+0xb00; SB_ConnBroken;;0;fsfw/src/fsfw/osal/common/TcpTmTcServer.h;SUBSYSTEM_BASE
 0x2901; IEC_NoConfigurationTable;;0x01;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
 0x2902; IEC_NoCpuTable;;0x02;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
 0x2903; IEC_InvalidWorkspaceAddress;;0x03;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
@@ -121,69 +200,26 @@
 0x2913; IEC_ImplementationBlockingOperationCancel;;0x13;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
 0x2914; IEC_MutexObtainFromBadState;;0x14;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
 0x2915; IEC_UnlimitedAndMaximumIs0;;0x15;fsfw/src/fsfw/osal/InternalErrorCodes.h;INTERNAL_ERROR_CODES
-0xe01; HM_InvalidMode;;0x01;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
+0x1401; SE_BufferTooShort;;1;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF
-0xe02; HM_TransNotAllowed;;0x02;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
+0x1402; SE_StreamTooShort;;2;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF
-0xe03; HM_InTransition;;0x03;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
+0x1403; SE_TooManyElements;;3;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF
-0xe04; HM_InvalidSubmode;;0x04;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
+0x4a00; SPPA_NoPacketFound;;0x00;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h;SPACE_PACKET_PARSER
-0x2d01; HPA_InvalidIdentifierId;;0x01;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
+0x4a01; SPPA_SplitPacket;;0x01;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h;SPACE_PACKET_PARSER
-0x2d02; HPA_InvalidDomainId;;0x02;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
+0x1d01; PUS_ActivityStarted;;1;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x2d03; HPA_InvalidValue;;0x03;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
+0x1d02; PUS_InvalidSubservice;;2;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x2d05; HPA_ReadOnly;;0x05;fsfw/src/fsfw/parameters/HasParametersIF.h;HAS_PARAMETERS_IF
+0x1d03; PUS_IllegalApplicationData;;3;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x2c01; PAW_UnknownDatatype;;0x01;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x1d04; PUS_SendTmFailed;;4;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x2c02; PAW_DatatypeMissmatch;;0x02;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x1d05; PUS_Timeout;;5;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x2c03; PAW_Readonly;;0x03;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x1f01; CSB_ExecutionComplete;;1;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x2c04; PAW_TooBig;;0x04;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x1f02; CSB_NoStepMessage;;2;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x2c05; PAW_SourceNotSet;;0x05;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x1f03; CSB_ObjectBusy;;3;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x2c06; PAW_OutOfBounds;;0x06;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x1f04; CSB_Busy;;4;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x2c07; PAW_NotSet;;0x07;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x1f05; CSB_InvalidTc;;5;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x2c08; PAW_ColumnOrRowsZero;;0x08;fsfw/src/fsfw/parameters/ParameterWrapper.h;PARAMETER_WRAPPER
+0x1f06; CSB_InvalidObject;;6;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x3101; CF_ObjectHasNoFunctions;;1;fsfw/src/fsfw/action/CommandsActionsIF.h;COMMANDS_ACTIONS_IF
+0x1f07; CSB_InvalidReply;;7;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x3102; CF_AlreadyCommanding;;2;fsfw/src/fsfw/action/CommandsActionsIF.h;COMMANDS_ACTIONS_IF
-0x3201; HF_IsBusy;;1;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
-0x3202; HF_InvalidParameters;;2;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
-0x3203; HF_ExecutionFinished;;3;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
-0x3204; HF_InvalidActionId;;4;fsfw/src/fsfw/action/HasActionsIF.h;HAS_ACTIONS_IF
-0x201; OM_InsertionFailed;;1;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
-0x202; OM_NotFound;;2;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
-0x203; OM_ChildInitFailed;;3;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
-0x204; OM_InternalErrReporterUninit;;4;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
 0x2500; FDI_YourFault;;0;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h;HANDLES_FAILURES_IF
 0x2501; FDI_MyFault;;1;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h;HANDLES_FAILURES_IF
 0x2502; FDI_ConfirmLater;;2;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h;HANDLES_FAILURES_IF
-0x2101; TMF_Busy;;1;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2102; TMF_LastPacketFound;;2;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2103; TMF_StopFetch;;3;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2104; TMF_Timeout;;4;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2105; TMF_TmChannelFull;;5;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2106; TMF_NotStored;;6;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2107; TMF_AllDeleted;;7;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2108; TMF_InvalidData;;8;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2109; TMF_NotReady;;9;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
-0x2001; TMB_Busy;;1;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2002; TMB_Full;;2;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2003; TMB_Empty;;3;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2004; TMB_NullRequested;;4;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2005; TMB_TooLarge;;5;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2006; TMB_NotReady;;6;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2007; TMB_DumpError;;7;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2008; TMB_CrcError;;8;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x2009; TMB_Timeout;;9;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x200a; TMB_IdlePacketFound;;10;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x200b; TMB_TelecommandFound;;11;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x200c; TMB_NoPusATm;;12;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x200d; TMB_TooSmall;;13;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x200e; TMB_BlockNotFound;;14;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x200f; TMB_InvalidRequest;;15;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
-0x1c01; TCD_PacketLost;;1;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION
-0x1c02; TCD_DestinationNotFound;;2;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION
-0x1c03; TCD_ServiceIdAlreadyExists;;3;fsfw/src/fsfw/tcdistribution/TcDistributor.h;PACKET_DISTRIBUTION
-0x1b00; TCC_IllegalApid;;0;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
-0x1b01; TCC_IncompletePacket;;1;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
-0x1b02; TCC_IncorrectChecksum;;2;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
-0x1b03; TCC_IllegalPacketType;;3;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
-0x1b04; TCC_IllegalPacketSubtype;;4;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
-0x1b05; TCC_IncorrectPrimaryHeader;;5;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
-0x1b06; TCC_IncorrectSecondaryHeader;;6;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h;TC_PACKET_CHECK
 0x4e1; RMP_CommandNoDescriptorsAvailable;;0xE1;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL
 0x4e2; RMP_CommandBufferFull;;0xE2;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL
 0x4e3; RMP_CommandChannelOutOfRange;;0xE3;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL
@@ -224,12 +260,35 @@
 0x40a; RMP_ReplyCommandNotImplementedOrNotAuthorised;;10;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL
 0x40b; RMP_ReplyRmwDataLengthError;;11;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL
 0x40c; RMP_ReplyInvalidTargetLogicalAddress;;12;fsfw/src/fsfw/rmap/RMAP.h;RMAP_CHANNEL
-0x2701; SM_DataTooLarge;;1;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
+0x2b01; CCS_BcIsSetVrCommand;;0x01;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2702; SM_DataStorageFull;;2;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
+0x2b02; CCS_BcIsUnlockCommand;;0x02;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2703; SM_IllegalStorageId;;3;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
+0x2bb0; CCS_BcIllegalCommand;;0xB0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2704; SM_DataDoesNotExist;;4;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
+0x2bb1; CCS_BoardReadingNotFinished;;0xB1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2705; SM_IllegalAddress;;5;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
+0x2bf0; CCS_NsPositiveW;;0xF0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
-0x2706; SM_PoolTooLarge;;6;fsfw/src/fsfw/storagemanager/StorageManagerIF.h;STORAGE_MANAGER_IF
+0x2bf1; CCS_NsNegativeW;;0xF1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bf2; CCS_NsLockout;;0xF2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bf3; CCS_FarmInLockout;;0xF3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bf4; CCS_FarmInWait;;0xF4;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be0; CCS_WrongSymbol;;0xE0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be1; CCS_DoubleStart;;0xE1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be2; CCS_StartSymbolMissed;;0xE2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be3; CCS_EndWithoutStart;;0xE3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be4; CCS_TooLarge;;0xE4;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be5; CCS_TooShort;;0xE5;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be6; CCS_WrongTfVersion;;0xE6;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be7; CCS_WrongSpacecraftId;;0xE7;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be8; CCS_NoValidFrameType;;0xE8;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2be9; CCS_CrcFailed;;0xE9;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bea; CCS_VcNotFound;;0xEA;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2beb; CCS_ForwardingFailed;;0xEB;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bec; CCS_ContentTooLarge;;0xEC;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bed; CCS_ResidualData;;0xED;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bee; CCS_DataCorrupted;;0xEE;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bef; CCS_IllegalSegmentationFlag;;0xEF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bd0; CCS_IllegalFlagCombination;;0xD0;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bd1; CCS_ShorterThanHeader;;0xD1;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bd2; CCS_TooShortBlockedPacket;;0xD2;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
+0x2bd3; CCS_TooShortMapExtraction;;0xD3;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h;CCSDS_HANDLER_IF
 0x37a1; SGP4_InvalidEccentricity;;0xA1;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
 0x37a2; SGP4_InvalidMeanMotion;;0xA2;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
 0x37a3; SGP4_InvalidPerturbationElements;;0xA3;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
@@ -238,142 +297,10 @@
 0x37a6; SGP4_SatelliteHasDecayed;;0xA6;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
 0x37b1; SGP4_TleTooOld;;0xB1;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
 0x37b2; SGP4_TleNotInitialized;;0xB2;fsfw/src/fsfw/coordinates/Sgp4Propagator.h;SGP4PROPAGATOR_CLASS
-0x2301; MT_TooDetailedRequest;;1;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS
+0x13e0; MH_UnknownCmd;;0xE0;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
-0x2302; MT_TooGeneralRequest;;2;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS
+0x13e1; MH_InvalidAddress;;0xE1;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
-0x2303; MT_NoMatch;;3;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS
+0x13e2; MH_InvalidSize;;0xE2;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
-0x2304; MT_Full;;4;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS
+0x13e3; MH_StateMismatch;;0xE3;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
-0x2305; MT_NewNodeCreated;;5;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h;MATCH_TREE_CLASS
-0x3e01; DLEE_StreamTooShort;;0x01;fsfw/src/fsfw/globalfunctions/DleEncoder.h;DLE_ENCODER
-0x3e02; DLEE_DecodingError;;0x02;fsfw/src/fsfw/globalfunctions/DleEncoder.h;DLE_ENCODER
-0x2e01; ASC_TooLongForTargetType;;1;fsfw/src/fsfw/globalfunctions/AsciiConverter.h;ASCII_CONVERTER
-0x2e02; ASC_InvalidCharacters;;2;fsfw/src/fsfw/globalfunctions/AsciiConverter.h;ASCII_CONVERTER
-0x2e03; ASC_BufferTooSmall;;0x3;fsfw/src/fsfw/globalfunctions/AsciiConverter.h;ASCII_CONVERTER
-0xf01; CM_UnknownCommand;;1;fsfw/src/fsfw/ipc/CommandMessageIF.h;COMMAND_MESSAGE
-0x3901; MQI_Empty;;1;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF
-0x3902; MQI_Full;No space left for more messages;2;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF
-0x3903; MQI_NoReplyPartner;Returned if a reply method was called without partner;3;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF
-0x3904; MQI_DestinationInvalid;Returned if the target destination is invalid.;4;fsfw/src/fsfw/ipc/MessageQueueIF.h;MESSAGE_QUEUE_IF
-0x3801; MUX_NotEnoughResources;;1;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
-0x3802; MUX_InsufficientMemory;;2;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
-0x3803; MUX_NoPrivilege;;3;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
-0x3804; MUX_WrongAttributeSetting;;4;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
-0x3805; MUX_MutexAlreadyLocked;;5;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
-0x3806; MUX_MutexNotFound;;6;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
-0x3807; MUX_MutexMaxLocks;;7;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
-0x3808; MUX_CurrThreadAlreadyOwnsMutex;;8;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
-0x3809; MUX_CurrThreadDoesNotOwnMutex;;9;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
-0x380a; MUX_MutexTimeout;;10;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
-0x380b; MUX_MutexInvalidId;;11;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
-0x380c; MUX_MutexDestroyedWhileWaiting;;12;fsfw/src/fsfw/ipc/MutexIF.h;MUTEX_IF
-0x3a01; SPH_SemaphoreTimeout;;1;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF
-0x3a02; SPH_SemaphoreNotOwned;;2;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF
-0x3a03; SPH_SemaphoreInvalid;;3;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF
-0x3501; CFDP_InvalidTlvType;;1;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x3502; CFDP_InvalidDirectiveFields;;2;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x3503; CFDP_InvalidPduDatafieldLen;;3;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x3504; CFDP_InvalidAckDirectiveFields;;4;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x3505; CFDP_MetadataCantParseOptions;;5;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x3506; CFDP_FinishedCantParseFsResponses;;6;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x3508; CFDP_FilestoreRequiresSecondFile;;8;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x3509; CFDP_FilestoreResponseCantParseFsMessage;;9;fsfw/src/fsfw/cfdp/definitions.h;CFDP
-0x2801; TC_InvalidTargetState;;1;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF
-0x28f1; TC_AboveOperationalLimit;;0xF1;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF
-0x28f2; TC_BelowOperationalLimit;;0xF2;fsfw/src/fsfw/thermal/ThermalComponentIF.h;THERMAL_COMPONENT_IF
-0xc02; MS_InvalidEntry;;0x02;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF
-0xc03; MS_TooManyElements;;0x03;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF
-0xc04; MS_CantStoreEmpty;;0x04;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h;MODE_STORE_IF
-0xd01; SS_SequenceAlreadyExists;;0x01;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xd02; SS_TableAlreadyExists;;0x02;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xd03; SS_TableDoesNotExist;;0x03;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xd04; SS_TableOrSequenceLengthInvalid;;0x04;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xd05; SS_SequenceDoesNotExist;;0x05;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xd06; SS_TableContainsInvalidObjectId;;0x06;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xd07; SS_FallbackSequenceDoesNotExist;;0x07;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xd08; SS_NoTargetTable;;0x08;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xd09; SS_SequenceOrTableTooLong;;0x09;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xd0b; SS_IsFallbackSequence;;0x0B;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xd0c; SS_AccessDenied;;0x0C;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xd0e; SS_TableInUse;;0x0E;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xda1; SS_TargetTableNotReached;;0xA1;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xda2; SS_TableCheckFailed;;0xA2;fsfw/src/fsfw/subsystem/Subsystem.h;SUBSYSTEM
-0xb01; SB_ChildNotFound;;0x01;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE
-0xb02; SB_ChildInfoUpdated;;0x02;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE
-0xb03; SB_ChildDoesntHaveModes;;0x03;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE
-0xb04; SB_CouldNotInsertChild;;0x04;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE
-0xb05; SB_TableContainsInvalidObjectId;;0x05;fsfw/src/fsfw/subsystem/SubsystemBase.h;SUBSYSTEM_BASE
-0x3d00; HKM_QueueOrDestinationInvalid;;0;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x3d01; HKM_WrongHkPacketType;;1;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x3d02; HKM_ReportingStatusUnchanged;;2;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x3d03; HKM_PeriodicHelperInvalid;;3;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x3d04; HKM_PoolobjectNotFound;;4;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x3d05; HKM_DatasetNotFound;;5;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h;HOUSEKEEPING_MANAGER
-0x3b00; LPIF_PoolEntryNotFound;;0x00;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h;LOCAL_POOL_OWNER_IF
-0x3b01; LPIF_PoolEntryTypeConflict;;0x01;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h;LOCAL_POOL_OWNER_IF
-0x3ca0; PVA_InvalidReadWriteMode;;0xA0;fsfw/src/fsfw/datapool/PoolVariableIF.h;POOL_VARIABLE_IF
-0x3ca1; PVA_InvalidPoolEntry;;0xA1;fsfw/src/fsfw/datapool/PoolVariableIF.h;POOL_VARIABLE_IF
-0x801; DPS_InvalidParameterDefinition;;1;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
-0x802; DPS_SetWasAlreadyRead;;2;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
-0x803; DPS_CommitingWithoutReading;;3;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
-0x804; DPS_DataSetUninitialised;;4;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
-0x805; DPS_DataSetFull;;5;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
-0x806; DPS_PoolVarNull;;6;fsfw/src/fsfw/datapool/DataSetIF.h;DATA_SET_CLASS
-0x1000; TIM_UnsupportedTimeFormat;;0;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
-0x1001; TIM_NotEnoughInformationForTargetFormat;;1;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
-0x1002; TIM_LengthMismatch;;2;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
-0x1003; TIM_InvalidTimeFormat;;3;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
-0x1004; TIM_InvalidDayOfYear;;4;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
-0x1005; TIM_TimeDoesNotFitFormat;;5;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
-0x3601; TSI_BadTimestamp;;1;fsfw/src/fsfw/timemanager/TimeStamperIF.h;TIME_STAMPER_IF
-0x1d01; PUS_ActivityStarted;;1;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x1d02; PUS_InvalidSubservice;;2;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x1d03; PUS_IllegalApplicationData;;3;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x1d04; PUS_SendTmFailed;;4;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x1d05; PUS_Timeout;;5;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h;ACCEPTS_TELECOMMANDS_IF
-0x4a00; SPPA_NoPacketFound;;0x00;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h;SPACE_PACKET_PARSER
-0x4a01; SPPA_SplitPacket;;0x01;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h;SPACE_PACKET_PARSER
-0x1f01; CSB_ExecutionComplete;;1;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x1f02; CSB_NoStepMessage;;2;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x1f03; CSB_ObjectBusy;;3;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x1f04; CSB_Busy;;4;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x1f05; CSB_InvalidTc;;5;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x1f06; CSB_InvalidObject;;6;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x1f07; CSB_InvalidReply;;7;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h;COMMAND_SERVICE_BASE
-0x1101; AL_Full;;0x01;fsfw/src/fsfw/container/ArrayList.h;ARRAY_LIST
-0x1801; FF_Full;;1;fsfw/src/fsfw/container/FIFOBase.h;FIFO_CLASS
-0x1802; FF_Empty;;2;fsfw/src/fsfw/container/FIFOBase.h;FIFO_CLASS
-0x1601; FMM_MapFull;;0x01;fsfw/src/fsfw/container/FixedOrderedMultimap.h;FIXED_MULTIMAP
-0x1602; FMM_KeyDoesNotExist;;0x02;fsfw/src/fsfw/container/FixedOrderedMultimap.h;FIXED_MULTIMAP
-0x1501; FM_KeyAlreadyExists;;0x01;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP
-0x1502; FM_MapFull;;0x02;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP
-0x1503; FM_KeyDoesNotExist;;0x03;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP
-0x2401; EV_ListenerNotFound;;1;fsfw/src/fsfw/events/EventManagerIF.h;EVENT_MANAGER_IF
-0x1701; HHI_ObjectNotHealthy;;1;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF
-0x1702; HHI_InvalidHealthState;;2;fsfw/src/fsfw/health/HasHealthIF.h;HAS_HEALTH_IF
-0x2f01; POS_InPowerTransition;;1;fsfw/src/fsfw/power/PowerSwitcher.h;POWER_SWITCHER
-0x2f02; POS_SwitchStateMismatch;;2;fsfw/src/fsfw/power/PowerSwitcher.h;POWER_SWITCHER
-0x501; PS_SwitchOn;;1;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x500; PS_SwitchOff;;0;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x502; PS_SwitchTimeout;;2;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x503; PS_FuseOn;;3;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x504; PS_FuseOff;;4;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x1a01; TRC_NotEnoughSensors;;1;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK
-0x1a02; TRC_LowestValueOol;;2;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK
-0x1a03; TRC_HighestValueOol;;3;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK
-0x1a04; TRC_BothValuesOol;;4;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK
-0x1a05; TRC_DuplexOol;;5;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK
-0x3001; LIM_Unchecked;;1;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x3002; LIM_Invalid;;2;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x3003; LIM_Unselected;;3;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x3004; LIM_BelowLowLimit;;4;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x3005; LIM_AboveHighLimit;;5;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x3006; LIM_UnexpectedValue;;6;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x3007; LIM_OutOfRange;;7;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x30a0; LIM_FirstSample;;0xA0;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x30e0; LIM_InvalidSize;;0xE0;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x30e1; LIM_WrongType;;0xE1;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x30e2; LIM_WrongPid;;0xE2;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x30e3; LIM_WrongLimitId;;0xE3;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x30ee; LIM_MonitorNotFound;;0xEE;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
 0x4100; FILS_GenericFileError;;0;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
 0x4101; FILS_IsBusy;;1;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
 0x4102; FILS_InvalidParameters;;2;fsfw/src/fsfw/memory/HasFileSystemIF.h;FILE_SYSTEM
@@ -399,16 +326,60 @@
 0x6e2; PP_InvalidContent;;0xE2;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
 0x6e3; PP_UnalignedAccess;;0xE3;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
 0x6e4; PP_WriteProtected;;0xE4;fsfw/src/fsfw/memory/HasMemoryIF.h;HAS_MEMORY_IF
-0x13e0; MH_UnknownCmd;;0xE0;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
+0x201; OM_InsertionFailed;;1;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
-0x13e1; MH_InvalidAddress;;0xE1;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
+0x202; OM_NotFound;;2;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
-0x13e2; MH_InvalidSize;;0xE2;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
+0x203; OM_ChildInitFailed;;3;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
-0x13e3; MH_StateMismatch;;0xE3;fsfw/src/fsfw/memory/MemoryHelper.h;MEMORY_HELPER
+0x204; OM_InternalErrReporterUninit;;4;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h;OBJECT_MANAGER_IF
-0x1201; AB_NeedSecondStep;;0x01;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
+0x501; PS_SwitchOn;;1;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x1202; AB_NeedToReconfigure;;0x02;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
+0x500; PS_SwitchOff;;0;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x1203; AB_ModeFallback;;0x03;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
+0x502; PS_SwitchTimeout;;2;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x1204; AB_ChildNotCommandable;;0x04;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
+0x503; PS_FuseOn;;3;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x1205; AB_NeedToChangeHealth;;0x05;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
+0x504; PS_FuseOff;;4;fsfw/src/fsfw/power/PowerSwitchIF.h;POWER_SWITCH_IF
-0x12a1; AB_NotEnoughChildrenInCorrectState;;0xa1;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
+0x2f01; POS_InPowerTransition;;1;fsfw/src/fsfw/power/PowerSwitcher.h;POWER_SWITCHER
+0x2f02; POS_SwitchStateMismatch;;2;fsfw/src/fsfw/power/PowerSwitcher.h;POWER_SWITCHER
+0x1000; TIM_UnsupportedTimeFormat;;0;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
+0x1001; TIM_NotEnoughInformationForTargetFormat;;1;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
+0x1002; TIM_LengthMismatch;;2;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
+0x1003; TIM_InvalidTimeFormat;;3;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
+0x1004; TIM_InvalidDayOfYear;;4;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
+0x1005; TIM_TimeDoesNotFitFormat;;5;fsfw/src/fsfw/timemanager/CCSDSTime.h;CCSDS_TIME_HELPER_CLASS
+0x3601; TSI_BadTimestamp;;1;fsfw/src/fsfw/timemanager/TimeStamperIF.h;TIME_STAMPER_IF
+0x2101; TMF_Busy;;1;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2102; TMF_LastPacketFound;;2;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2103; TMF_StopFetch;;3;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2104; TMF_Timeout;;4;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2105; TMF_TmChannelFull;;5;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2106; TMF_NotStored;;6;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2107; TMF_AllDeleted;;7;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2108; TMF_InvalidData;;8;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2109; TMF_NotReady;;9;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h;TM_STORE_FRONTEND_IF
+0x2001; TMB_Busy;;1;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2002; TMB_Full;;2;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2003; TMB_Empty;;3;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2004; TMB_NullRequested;;4;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2005; TMB_TooLarge;;5;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2006; TMB_NotReady;;6;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2007; TMB_DumpError;;7;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2008; TMB_CrcError;;8;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x2009; TMB_Timeout;;9;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x200a; TMB_IdlePacketFound;;10;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x200b; TMB_TelecommandFound;;11;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x200c; TMB_NoPusATm;;12;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x200d; TMB_TooSmall;;13;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x200e; TMB_BlockNotFound;;14;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0x200f; TMB_InvalidRequest;;15;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h;TM_STORE_BACKEND_IF
+0xe01; HM_InvalidMode;;0x01;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
+0xe02; HM_TransNotAllowed;;0x02;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
+0xe03; HM_InTransition;;0x03;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
+0xe04; HM_InvalidSubmode;;0x04;fsfw/src/fsfw/modes/HasModesIF.h;HAS_MODES_IF
+0x1501; FM_KeyAlreadyExists;;0x01;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP
+0x1502; FM_MapFull;;0x02;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP
+0x1503; FM_KeyDoesNotExist;;0x03;fsfw/src/fsfw/container/FixedMap.h;FIXED_MAP
+0x1101; AL_Full;;0x01;fsfw/src/fsfw/container/ArrayList.h;ARRAY_LIST
+0x1601; FMM_MapFull;;0x01;fsfw/src/fsfw/container/FixedOrderedMultimap.h;FIXED_MULTIMAP
+0x1602; FMM_KeyDoesNotExist;;0x02;fsfw/src/fsfw/container/FixedOrderedMultimap.h;FIXED_MULTIMAP
+0x1801; FF_Full;;1;fsfw/src/fsfw/container/FIFOBase.h;FIFO_CLASS
+0x1802; FF_Empty;;2;fsfw/src/fsfw/container/FIFOBase.h;FIFO_CLASS
 0x3a0; DHB_InvalidChannel;;0xA0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
 0x3b0; DHB_AperiodicReply;;0xB0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
 0x3b1; DHB_IgnoreReplyData;;0xB1;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
@@ -418,12 +389,12 @@
 0x3d0; DHB_NoSwitch;;0xD0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
 0x3e0; DHB_ChildTimeout;;0xE0;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
 0x3e1; DHB_SwitchFailed;;0xE1;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h;DEVICE_HANDLER_BASE
-0x3301; DC_NoReplyReceived;;0x01;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
+0x1201; AB_NeedSecondStep;;0x01;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
-0x3302; DC_ProtocolError;;0x02;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
+0x1202; AB_NeedToReconfigure;;0x02;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
-0x3303; DC_Nullpointer;;0x03;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
+0x1203; AB_ModeFallback;;0x03;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
-0x3304; DC_InvalidCookieType;;0x04;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
+0x1204; AB_ChildNotCommandable;;0x04;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
-0x3305; DC_NotActive;;0x05;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
+0x1205; AB_NeedToChangeHealth;;0x05;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
-0x3306; DC_TooMuchData;;0x06;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
+0x12a1; AB_NotEnoughChildrenInCorrectState;;0xa1;fsfw/src/fsfw/devicehandlers/AssemblyBase.h;ASSEMBLY_BASE
 0x26a0; DHI_NoCommandData;;0xA0;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
 0x26a1; DHI_CommandNotSupported;;0xA1;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
 0x26a2; DHI_CommandAlreadySent;;0xA2;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
@@ -445,48 +416,87 @@
 0x26c3; DHI_DeviceReplyInvalid;;0xC3;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
 0x26d0; DHI_InvalidCommandParameter;;0xD0;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
 0x26d1; DHI_InvalidNumberOrLengthOfParameters;;0xD1;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h;DEVICE_HANDLER_IF
-0x1401; SE_BufferTooShort;;1;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF
+0x3301; DC_NoReplyReceived;;0x01;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
-0x1402; SE_StreamTooShort;;2;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF
+0x3302; DC_ProtocolError;;0x02;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
-0x1403; SE_TooManyElements;;3;fsfw/src/fsfw/serialize/SerializeIF.h;SERIALIZE_IF
+0x3303; DC_Nullpointer;;0x03;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
-0x58a0;PLSV_CrcFailure;Space Packet received from PLOC supervisor has invalid CRC;0xA0;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x3304; DC_InvalidCookieType;;0x04;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
-0x58a1;PLSV_ReceivedAckFailure;Received ACK failure reply from PLOC supervisor;0xA1;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x3305; DC_NotActive;;0x05;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
-0x58a2;PLSV_ReceivedExeFailure;Received execution failure reply from PLOC supervisor;0xA2;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x3306; DC_TooMuchData;;0x06;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h;DEVICE_COMMUNICATION_IF
-0x58a3;PLSV_InvalidApid;Received space packet with invalid APID from PLOC supervisor;0xA3;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x2401; EV_ListenerNotFound;;1;fsfw/src/fsfw/events/EventManagerIF.h;EVENT_MANAGER_IF
-0x58a4;PLSV_GetTimeFailure;Failed to read current system time;0xA4;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x1a01; TRC_NotEnoughSensors;;1;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK
-0x58a5;PLSV_InvalidUartComIf;Invalid communication interface specified;0xA5;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x1a02; TRC_LowestValueOol;;2;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK
-0x58a6;PLSV_InvalidWatchdog;Received command with invalid watchdog parameter. Valid watchdogs are 0 for PS, 1 for PL and 2 for INT;0xA6;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x1a03; TRC_HighestValueOol;;3;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK
-0x58a7;PLSV_InvalidWatchdogTimeout;Received watchdog timeout config command with invalid timeout. Valid timeouts must be in the range between 1000 and 360000 ms.;0xA7;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x1a04; TRC_BothValuesOol;;4;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK
-0x58a8;PLSV_InvalidLatchupId;Received latchup config command with invalid latchup ID;0xA8;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x1a05; TRC_DuplexOol;;5;fsfw/src/fsfw/monitoring/TriplexMonitor.h;TRIPLE_REDUNDACY_CHECK
-0x58a9;PLSV_SweepPeriodTooSmall;Received set adc sweep period command with invalid sweep period. Must be larger than 21.;0xA9;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x3001; LIM_Unchecked;;1;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x58aa;PLSV_InvalidTestParam;Receive auto EM test command with invalid test param. Valid params are 1 and 2.;0xAA;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x3002; LIM_Invalid;;2;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x58ab;PLSV_MramPacketParsingFailure;Returned when scanning for MRAM dump packets failed.;0xAB;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x3003; LIM_Unselected;;3;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x58ac;PLSV_InvalidMramAddresses;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);0xAC;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x3004; LIM_BelowLowLimit;;4;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x58ad;PLSV_NoMramPacket;Expect reception of an MRAM dump packet but received space packet with other apid.;0xAD;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x3005; LIM_AboveHighLimit;;5;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x58ae;PLSV_PathDoesNotExist;Path to PLOC directory on SD card does not exist;0xAE;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x3006; LIM_UnexpectedValue;;6;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x58af;PLSV_MramFileNotExists;MRAM dump file does not exists. The file should actually already have been created with the reception of the first dump packet.;0xAF;bsp_q7s/devices/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x3007; LIM_OutOfRange;;7;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x5fa0;PLMEMDUMP_MramAddressTooHigh;The capacity of the MRAM amounts to 512 kB. Thus the maximum address must not be higher than 0x7d000.;0xA0;bsp_q7s/devices/PlocMemoryDumper.h;PLOC_MEMORY_DUMPER
+0x30a0; LIM_FirstSample;;0xA0;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x5fa1;PLMEMDUMP_MramInvalidAddressCombination;The specified end address is lower than the start address;0xA1;bsp_q7s/devices/PlocMemoryDumper.h;PLOC_MEMORY_DUMPER
+0x30e0; LIM_InvalidSize;;0xE0;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x5ca0;PLUD_UpdaterBusy;Updater is already performing an update;0xA0;bsp_q7s/devices/PlocUpdater.h;PLOC_UPDATER
+0x30e1; LIM_WrongType;;0xE1;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x5ca1;PLUD_NameTooLong;Received update command with invalid path string (too long).;0xA1;bsp_q7s/devices/PlocUpdater.h;PLOC_UPDATER
+0x30e2; LIM_WrongPid;;0xE2;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x5ca2;PLUD_SdNotMounted;Received command to initiate update but SD card with update image not mounted.;0xA2;bsp_q7s/devices/PlocUpdater.h;PLOC_UPDATER
+0x30e3; LIM_WrongLimitId;;0xE3;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x5ca3;PLUD_FileNotExists;Update file received with update command does not exist.;0xA3;bsp_q7s/devices/PlocUpdater.h;PLOC_UPDATER
+0x30ee; LIM_MonitorNotFound;;0xEE;fsfw/src/fsfw/monitoring/MonitoringIF.h;LIMITS_IF
-0x6c00; SDMA_OpOngoing;;0;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
+0x3a01; SPH_SemaphoreTimeout;;1;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF
-0x6c01; SDMA_AlreadyOn;;1;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
+0x3a02; SPH_SemaphoreNotOwned;;2;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF
-0x6c02; SDMA_AlreadyMounted;;2;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
+0x3a03; SPH_SemaphoreInvalid;;3;fsfw/src/fsfw/tasks/SemaphoreIF.h;SEMAPHORE_IF
-0x6c03; SDMA_AlreadyOff;;3;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
+0x7000; SDMA_OpOngoing;;0;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
-0x6c0a; SDMA_StatusFileNexists;;10;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
+0x7001; SDMA_AlreadyOn;;1;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
-0x6c0b; SDMA_StatusFileFormatInvalid;;11;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
+0x7002; SDMA_AlreadyMounted;;2;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
-0x6c0c; SDMA_MountError;;12;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
+0x7003; SDMA_AlreadyOff;;3;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
-0x6c0d; SDMA_UnmountError;;13;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
+0x700a; SDMA_StatusFileNexists;;10;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
-0x6c0e; SDMA_SystemCallError;;14;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
+0x700b; SDMA_StatusFileFormatInvalid;;11;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
-0x6c0f; SDMA_PopenCallError;;15;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
+0x700c; SDMA_MountError;;12;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
-0x6d00; SCBU_KeyNotFound;;0;bsp_q7s/memory/scratchApi.h;SCRATCH_BUFFER
+0x700d; SDMA_UnmountError;;13;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
+0x700e; SDMA_SystemCallError;;14;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
+0x700f; SDMA_PopenCallError;;15;bsp_q7s/memory/SdCardManager.h;SD_CARD_MANAGER
+0x7100; SCBU_KeyNotFound;;0;bsp_q7s/memory/scratchApi.h;SCRATCH_BUFFER
+0x66a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;0xA0;bsp_q7s/memory/FilesystemHelper.h;FILE_SYSTEM_HELPER
+0x66a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;0xA1;bsp_q7s/memory/FilesystemHelper.h;FILE_SYSTEM_HELPER
+0x69a0;MPSOCRTVIF_CrcFailure;Space Packet received from PLOC has invalid CRC;0xA0;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF
+0x69a1;MPSOCRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC;0xA1;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF
+0x69a2;MPSOCRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC;0xA2;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF
+0x69a3;MPSOCRTVIF_InvalidApid;Received space packet with invalid APID from PLOC;0xA3;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF
+0x69a4;MPSOCRTVIF_InvalidLength;Received command with invalid length;0xA4;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF
+0x69a5;MPSOCRTVIF_FilenameTooLong;Filename of file in OBC filesystem is too long;0xA5;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF
+0x69a6;MPSOCRTVIF_MpsocHelperExecuting;MPSoC helper is currently executing a command;0xA6;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF
+0x69a7;MPSOCRTVIF_MpsocFilenameTooLong;Filename of MPSoC file is to long (max. 256 bytes);0xA7;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF
+0x69a8;MPSOCRTVIF_InvalidParameter;Command has invalid parameter;0xA8;linux/devices/devicedefinitions/MPSoCReturnValuesIF.h;MPSOC_RETURN_VALUES_IF
+0x57e0;DWLPWRON_InvalidMode;Received command has invalid JESD mode (valid modes are 0 - 5);0xE0;linux/devices/devicedefinitions/PlocMPSoCDefinitions.h;DWLPWRON_CMD
+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
+0x5da3;PLUD_FileNotExists;Update file received with update command does not exist.;0xA3;linux/devices/ploc/PlocUpdater.h;PLOC_UPDATER
+0x59a0;PLSV_CrcFailure;Space Packet received from PLOC supervisor has invalid CRC;0xA0;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59a1;PLSV_ReceivedAckFailure;Received ACK failure reply from PLOC supervisor;0xA1;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59a2;PLSV_ReceivedExeFailure;Received execution failure reply from PLOC supervisor;0xA2;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59a3;PLSV_InvalidApid;Received space packet with invalid APID from PLOC supervisor;0xA3;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59a4;PLSV_GetTimeFailure;Failed to read current system time;0xA4;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59a5;PLSV_InvalidWatchdog;Received command with invalid watchdog parameter. Valid watchdogs are 0 for PS, 1 for PL and 2 for INT;0xA5;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59a6;PLSV_InvalidWatchdogTimeout;Received watchdog timeout config command with invalid timeout. Valid timeouts must be in the range between 1000 and 360000 ms.;0xA6;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59a7;PLSV_InvalidLatchupId;Received latchup config command with invalid latchup ID;0xA7;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59a8;PLSV_SweepPeriodTooSmall;Received set adc sweep period command with invalid sweep period. Must be larger than 21.;0xA8;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59a9;PLSV_InvalidTestParam;Receive auto EM test command with invalid test param. Valid params are 1 and 2.;0xA9;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59aa;PLSV_MramPacketParsingFailure;Returned when scanning for MRAM dump packets failed.;0xAA;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59ab;PLSV_InvalidMramAddresses;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);0xAB;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59ac;PLSV_NoMramPacket;Expect reception of an MRAM dump packet but received space packet with other apid.;0xAC;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59ad;PLSV_PathDoesNotExist;Path to PLOC directory on SD card does not exist;0xAD;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59ae;PLSV_MramFileNotExists;MRAM dump file does not exists. The file should actually already have been created with the reception of the first dump packet.;0xAE;linux/devices/ploc/PlocSupervisorHandler.h;PLOC_SUPERVISOR_HANDLER
+0x59d0;PLSV_NameTooLong;Received command has file string with invalid length;0xD0;linux/devices/ploc/PlocMPSoCHandler.h;PLOC_SUPERVISOR_HANDLER
+0x6401;JSONBASE_JsonFileNotExists;Specified json file does not exist;1;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE
+0x6402;JSONBASE_SetNotExists;Requested set does not exist in json file;2;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE
+0x6403;JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE
 0x56a0;STRH_TemperatureReqFailed;Status in temperature reply signals error;0xA0;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
 0x56a1;STRH_PingFailed;Ping command failed;0xA1;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
 0x56a2;STRH_VersionReqFailed;Status in version reply signals error;0xA2;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x6301;JSONBASE_JsonFileNotExists;Specified json file does not exist;1;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE
-0x6302;JSONBASE_SetNotExists;Requested set does not exist in json file;2;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE
-0x6303;JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;linux/devices/startracker/ArcsecJsonParamBase.h;ARCSEC_JSON_BASE
 0x56a3;STRH_InterfaceReqFailed;Status in interface reply signals error;0xA3;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
 0x56a4;STRH_PowerReqFailed;Status in power reply signals error;0xA4;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
 0x56a5;STRH_SetParamFailed;Status of reply to parameter set command signals error;0xA5;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
@@ -509,33 +519,33 @@
 0x56b6;STRH_StartrackerAlreadyBooted;Star tracker is already in firmware mode;0xB6;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
 0x56b7;STRH_StartrackerRunningFirmware;Star tracker is in firmware mode but must be in bootloader mode to execute this command;0xB7;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
 0x56b8;STRH_StartrackerRunningBootloader;Star tracker is in bootloader mode but must be in firmware mode to execute this command;0xB8;linux/devices/startracker/StarTrackerHandler.h;STR_HANDLER
-0x5da0;STRHLP_SdNotMounted;SD card specified in path string not mounted;0xA0;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x5ea0;STRHLP_SdNotMounted;SD card specified in path string not mounted;0xA0;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x5da1;STRHLP_FileNotExists;Specified file does not exist on filesystem;0xA1;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x5ea1;STRHLP_FileNotExists;Specified file does not exist on filesystem;0xA1;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x5da2;STRHLP_PathNotExists;Specified path does not exist;0xA2;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x5ea2;STRHLP_PathNotExists;Specified path does not exist;0xA2;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x5da3;STRHLP_FileCreationFailed;Failed to create download image or read flash file;0xA3;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x5ea3;STRHLP_FileCreationFailed;Failed to create download image or read flash file;0xA3;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x5da4;STRHLP_RegionMismatch;Region in flash write/read reply does not match expected region;0xA4;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x5ea4;STRHLP_RegionMismatch;Region in flash write/read reply does not match expected region;0xA4;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x5da5;STRHLP_AddressMismatch;Address in flash write/read reply does not match expected address;0xA5;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x5ea5;STRHLP_AddressMismatch;Address in flash write/read reply does not match expected address;0xA5;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x5da6;STRHLP_LengthMismatch;Length in flash write/read reply does not match expected length;0xA6;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x5ea6;STRHLP_LengthMismatch;Length in flash write/read reply does not match expected length;0xA6;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x5da7;STRHLP_StatusError;Status field in reply signals error;0xA7;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x5ea7;STRHLP_StatusError;Status field in reply signals error;0xA7;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x5da8;STRHLP_InvalidTypeId;Reply has invalid type ID (should be of action reply type);0xA8;linux/devices/startracker/StrHelper.h;STR_HELPER
+0x5ea8;STRHLP_InvalidTypeId;Reply has invalid type ID (should be of action reply type);0xA8;linux/devices/startracker/StrHelper.h;STR_HELPER
-0x5aa0;IPCI_PapbBusy;;0xA0;linux/obc/PapbVcInterface.h;CCSDS_IP_CORE_BRIDGE
+0x5ba0;IPCI_PapbBusy;;0xA0;linux/obc/PapbVcInterface.h;CCSDS_IP_CORE_BRIDGE
-0x5ba0;PTME_UnknownVcId;;0xA0;linux/obc/Ptme.h;PTME
+0x5ca0;PTME_UnknownVcId;;0xA0;linux/obc/Ptme.h;PTME
-0x60a0;PDEC_AbandonedCltu;;0xA0;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x63a0;RS_RateNotSupported;The commanded rate is not supported by the current FPGA design;0xA0;linux/obc/PtmeConfig.h;RATE_SETTER
-0x60a1;PDEC_FrameDirty;;0xA1;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x63a1;RS_BadBitRate;Bad bitrate has been commanded (e.g. 0);0xA1;linux/obc/PtmeConfig.h;RATE_SETTER
-0x60a2;PDEC_FrameIllegalMultipleReasons;;0xA2;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x63a2;RS_ClkInversionFailed;Failed to invert clock and thus change the time the data is updated with respect to the tx clock;0xA2;linux/obc/PtmeConfig.h;RATE_SETTER
-0x60a3;PDEC_AdDiscardedLockout;;0xA3;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x63a3;RS_TxManipulatorConfigFailed;Failed to change configuration bit of tx clock manipulator;0xA3;linux/obc/PtmeConfig.h;RATE_SETTER
-0x60a4;PDEC_AdDiscardedWait;;0xA4;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x61a0;PDEC_AbandonedCltu;;0xA0;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x60a5;PDEC_AdDiscardedNsVs;;0xA5;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x61a1;PDEC_FrameDirty;;0xA1;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x60b0;PDEC_CommandNotImplemented;Received action message with unknown action id;0xB0;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x61a2;PDEC_FrameIllegalMultipleReasons;;0xA2;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x60a6;PDEC_NoReport;;0xA6;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x61a3;PDEC_AdDiscardedLockout;;0xA3;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x60a7;PDEC_ErrorVersionNumber;;0xA7;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x61a4;PDEC_AdDiscardedWait;;0xA4;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x60a8;PDEC_IllegalCombination;;0xA8;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x61a5;PDEC_AdDiscardedNsVs;;0xA5;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x60a9;PDEC_InvalidScId;;0xA9;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x61b0;PDEC_CommandNotImplemented;Received action message with unknown action id;0xB0;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x60aa;PDEC_InvalidVcIdMsb;;0xAA;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x61a6;PDEC_NoReport;;0xA6;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x60ab;PDEC_InvalidVcIdLsb;;0xAB;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x61a7;PDEC_ErrorVersionNumber;;0xA7;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x60ac;PDEC_NsNotZero;;0xAC;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x61a8;PDEC_IllegalCombination;;0xA8;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x60ae;PDEC_InvalidBcCc;;0xAE;linux/obc/PdecHandler.h;PDEC_HANDLER
+0x61a9;PDEC_InvalidScId;;0xA9;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x62a0;RS_RateNotSupported;The commanded rate is not supported by the current FPGA design;0xA0;linux/obc/PtmeConfig.h;RATE_SETTER
+0x61aa;PDEC_InvalidVcIdMsb;;0xAA;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x62a1;RS_BadBitRate;Bad bitrate has been commanded (e.g. 0);0xA1;linux/obc/PtmeConfig.h;RATE_SETTER
+0x61ab;PDEC_InvalidVcIdLsb;;0xAB;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x62a2;RS_ClkInversionFailed;Failed to invert clock and thus change the time the data is updated with respect to the tx clock;0xA2;linux/obc/PtmeConfig.h;RATE_SETTER
+0x61ac;PDEC_NsNotZero;;0xAC;linux/obc/PdecHandler.h;PDEC_HANDLER
-0x62a3;RS_TxManipulatorConfigFailed;Failed to change configuration bit of tx clock manipulator;0xA3;linux/obc/PtmeConfig.h;RATE_SETTER
+0x61ae;PDEC_InvalidBcCc;;0xAE;linux/obc/PdecHandler.h;PDEC_HANDLER

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 168 translations.
+ * @brief    Auto-generated event translation file. Contains 181 translations.
  * @details
- * Generated on: 2022-03-22 20:43:04
+ * Generated on: 2022-03-28 12:48:26
  */
 #include "translateEvents.h"
 
@@ -100,7 +100,8 @@ const char *DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_ON_FAI
 const char *MEMORY_READ_RPT_CRC_FAILURE_STRING = "MEMORY_READ_RPT_CRC_FAILURE";
 const char *ACK_FAILURE_STRING = "ACK_FAILURE";
 const char *EXE_FAILURE_STRING = "EXE_FAILURE";
-const char *CRC_FAILURE_EVENT_STRING = "CRC_FAILURE_EVENT";
+const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE";
+const char *MPSOC_HANDLER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQ_CNT_MISMATCH";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@@ -148,6 +149,18 @@ const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH";
 const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS";
 const char *STR_HELPER_SENDING_PACKET_FAILED_STRING = "STR_HELPER_SENDING_PACKET_FAILED";
 const char *STR_HELPER_REQUESTING_MSG_FAILED_STRING = "STR_HELPER_REQUESTING_MSG_FAILED";
+const char *MPSOC_FLASH_WRITE_FAILED_STRING = "MPSOC_FLASH_WRITE_FAILED";
+const char *MPSOC_FLASH_WRITE_SUCCESSFUL_STRING = "MPSOC_FLASH_WRITE_SUCCESSFUL";
+const char *SENDING_COMMAND_FAILED_STRING = "SENDING_COMMAND_FAILED";
+const char *MPSOC_HELPER_REQUESTING_REPLY_FAILED_STRING = "MPSOC_HELPER_REQUESTING_REPLY_FAILED";
+const char *MPSOC_HELPER_READING_REPLY_FAILED_STRING = "MPSOC_HELPER_READING_REPLY_FAILED";
+const char *MISSING_ACK_STRING = "MISSING_ACK";
+const char *MISSING_EXE_STRING = "MISSING_EXE";
+const char *ACK_FAILURE_REPORT_STRING = "ACK_FAILURE_REPORT";
+const char *EXE_FAILURE_REPORT_STRING = "EXE_FAILURE_REPORT";
+const char *ACK_INVALID_APID_STRING = "ACK_INVALID_APID";
+const char *EXE_INVALID_APID_STRING = "EXE_INVALID_APID";
+const char *MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HELPER_SEQ_CNT_MISMATCH";
 const char *TRANSITION_BACK_TO_OFF_STRING = "TRANSITION_BACK_TO_OFF";
 const char *NEG_V_OUT_OF_BOUNDS_STRING = "NEG_V_OUT_OF_BOUNDS";
 const char *U_DRO_OUT_OF_BOUNDS_STRING = "U_DRO_OUT_OF_BOUNDS";
@@ -363,7 +376,9 @@ const char *translateEvents(Event event) {
     case (11103):
       return EXE_FAILURE_STRING;
     case (11104):
-      return CRC_FAILURE_EVENT_STRING;
+      return MPSOC_HANDLER_CRC_FAILURE_STRING;
+    case (11105):
+      return MPSOC_HANDLER_SEQ_CNT_MISMATCH_STRING;
     case (11201):
       return SELF_TEST_I2C_FAILURE_STRING;
     case (11202):
@@ -459,38 +474,62 @@ const char *translateEvents(Event event) {
     case (12016):
       return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
     case (12100):
-      return TRANSITION_BACK_TO_OFF_STRING;
+      return MPSOC_FLASH_WRITE_FAILED_STRING;
     case (12101):
-      return NEG_V_OUT_OF_BOUNDS_STRING;
+      return MPSOC_FLASH_WRITE_SUCCESSFUL_STRING;
     case (12102):
-      return U_DRO_OUT_OF_BOUNDS_STRING;
+      return SENDING_COMMAND_FAILED_STRING;
     case (12103):
-      return I_DRO_OUT_OF_BOUNDS_STRING;
+      return MPSOC_HELPER_REQUESTING_REPLY_FAILED_STRING;
     case (12104):
-      return U_X8_OUT_OF_BOUNDS_STRING;
+      return MPSOC_HELPER_READING_REPLY_FAILED_STRING;
     case (12105):
-      return I_X8_OUT_OF_BOUNDS_STRING;
+      return MISSING_ACK_STRING;
     case (12106):
-      return U_TX_OUT_OF_BOUNDS_STRING;
+      return MISSING_EXE_STRING;
     case (12107):
-      return I_TX_OUT_OF_BOUNDS_STRING;
+      return ACK_FAILURE_REPORT_STRING;
     case (12108):
-      return U_MPA_OUT_OF_BOUNDS_STRING;
+      return EXE_FAILURE_REPORT_STRING;
     case (12109):
-      return I_MPA_OUT_OF_BOUNDS_STRING;
+      return ACK_INVALID_APID_STRING;
     case (12110):
-      return U_HPA_OUT_OF_BOUNDS_STRING;
+      return EXE_INVALID_APID_STRING;
     case (12111):
-      return I_HPA_OUT_OF_BOUNDS_STRING;
+      return MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING;
     case (12200):
-      return TRANSITION_OTHER_SIDE_FAILED_STRING;
+      return TRANSITION_BACK_TO_OFF_STRING;
     case (12201):
-      return NOT_ENOUGH_DEVICES_DUAL_MODE_STRING;
+      return NEG_V_OUT_OF_BOUNDS_STRING;
     case (12202):
-      return POWER_STATE_MACHINE_TIMEOUT_STRING;
+      return U_DRO_OUT_OF_BOUNDS_STRING;
     case (12203):
+      return I_DRO_OUT_OF_BOUNDS_STRING;
+    case (12204):
+      return U_X8_OUT_OF_BOUNDS_STRING;
+    case (12205):
+      return I_X8_OUT_OF_BOUNDS_STRING;
+    case (12206):
+      return U_TX_OUT_OF_BOUNDS_STRING;
+    case (12207):
+      return I_TX_OUT_OF_BOUNDS_STRING;
+    case (12208):
+      return U_MPA_OUT_OF_BOUNDS_STRING;
+    case (12209):
+      return I_MPA_OUT_OF_BOUNDS_STRING;
+    case (12210):
+      return U_HPA_OUT_OF_BOUNDS_STRING;
+    case (12211):
+      return I_HPA_OUT_OF_BOUNDS_STRING;
+    case (12300):
+      return TRANSITION_OTHER_SIDE_FAILED_STRING;
+    case (12301):
+      return NOT_ENOUGH_DEVICES_DUAL_MODE_STRING;
+    case (12302):
+      return POWER_STATE_MACHINE_TIMEOUT_STRING;
+    case (12303):
       return SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING;
-    case (12400):
+    case (12500):
       return CHILDREN_LOST_MODE_STRING;
     case (13600):
       return ALLOC_FAILURE_STRING;

generators/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 115 translations.
+ * Contains 117 translations.
- * Generated on: 2022-03-22 20:43:04
+ * Generated on: 2022-03-28 12:48:33
  */
 #include "translateObjects.h"
 
@@ -48,8 +48,10 @@ const char *RAD_SENSOR_STRING = "RAD_SENSOR";
 const char *PLOC_UPDATER_STRING = "PLOC_UPDATER";
 const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER";
 const char *STR_HELPER_STRING = "STR_HELPER";
+const char *PLOC_MPSOC_HELPER_STRING = "PLOC_MPSOC_HELPER";
 const char *PLOC_MPSOC_HANDLER_STRING = "PLOC_MPSOC_HANDLER";
 const char *PLOC_SUPERVISOR_HANDLER_STRING = "PLOC_SUPERVISOR_HANDLER";
+const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER";
 const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
 const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
 const char *TMP1075_HANDLER_1_STRING = "TMP1075_HANDLER_1";
@@ -208,10 +210,14 @@ const char *translateObject(object_id_t object) {
       return PLOC_MEMORY_DUMPER_STRING;
     case 0x44330002:
       return STR_HELPER_STRING;
+    case 0x44330003:
+      return PLOC_MPSOC_HELPER_STRING;
     case 0x44330015:
       return PLOC_MPSOC_HANDLER_STRING;
     case 0x44330016:
       return PLOC_SUPERVISOR_HANDLER_STRING;
+    case 0x44330017:
+      return PLOC_SUPERVISOR_HELPER_STRING;
     case 0x444100A2:
       return SOLAR_ARRAY_DEPL_HANDLER_STRING;
     case 0x444100A4:

linux/boardtest/SpiTestClass.cpp

@@ -339,6 +339,8 @@ void SpiTestClass::performMax1227Test() {
   std::string deviceName = "";
 #elif defined(EGSE)
   std::string deviceName = "";
+#elif defined(TE0720_1CFA)
+  std::string deviceName = "";
 #endif
   int fd = 0;
   UnixFileGuard fileHelper(deviceName, &fd, O_RDWR, "SpiComIF::initializeInterface");

linux/devices/CMakeLists.txt

@@ -4,4 +4,5 @@ if(EIVE_BUILD_GPSD_GPS_HANDLER)
     )
 endif()
 
+add_subdirectory(ploc)
 add_subdirectory(startracker)

linux/devices/devicedefinitions/MPSoCReturnValuesIF.h

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

linux/devices/devicedefinitions/PlocMPSoCDefinitions.h

@@ -0,0 +1,620 @@
+#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
+#define MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
+
+#include "MPSoCReturnValuesIF.h"
+#include "OBSWConfig.h"
+#include "eive/definitions.h"
+#include "fsfw/globalfunctions/CRC.h"
+#include "fsfw/serialize/SerializeAdapter.h"
+#include "fsfw/tmtcpacket/SpacePacket.h"
+
+namespace mpsoc {
+
+static const DeviceCommandId_t NONE = 0;
+static const DeviceCommandId_t TC_MEM_WRITE = 1;
+static const DeviceCommandId_t TC_MEM_READ = 2;
+static const DeviceCommandId_t ACK_REPORT = 3;
+static const DeviceCommandId_t EXE_REPORT = 5;
+static const DeviceCommandId_t TM_MEMORY_READ_REPORT = 6;
+static const DeviceCommandId_t TC_FLASHFOPEN = 7;
+static const DeviceCommandId_t TC_FLASHFCLOSE = 8;
+static const DeviceCommandId_t TC_FLASHWRITE = 9;
+static const DeviceCommandId_t TC_FLASHDELETE = 10;
+static const DeviceCommandId_t TC_REPLAY_START = 11;
+static const DeviceCommandId_t TC_REPLAY_STOP = 12;
+static const DeviceCommandId_t TC_REPLAY_WRITE_SEQUENCE = 13;
+static const DeviceCommandId_t TC_DOWNLINK_PWR_ON = 14;
+static const DeviceCommandId_t TC_DOWNLINK_PWR_OFF = 15;
+static const DeviceCommandId_t TC_MODE_REPLAY = 16;
+
+// Will reset the sequence count of the OBSW
+static const DeviceCommandId_t OBSW_RESET_SEQ_COUNT = 50;
+
+static const uint16_t SIZE_ACK_REPORT = 14;
+static const uint16_t SIZE_EXE_REPORT = 14;
+static const uint16_t SIZE_TM_MEM_READ_REPORT = 18;
+
+/**
+ * SpacePacket apids of PLOC telecommands and telemetry.
+ */
+namespace apid {
+static const uint16_t TC_REPLAY_START = 0x110;
+static const uint16_t TC_REPLAY_STOP = 0x111;
+static const uint16_t TC_REPLAY_WRITE_SEQUENCE = 0x112;
+static const uint16_t TC_DOWNLINK_PWR_ON = 0x113;
+static const uint16_t TC_MEM_WRITE = 0x114;
+static const uint16_t TC_MEM_READ = 0x115;
+static const uint16_t TC_FLASHWRITE = 0x117;
+static const uint16_t TC_FLASHFOPEN = 0x119;
+static const uint16_t TC_FLASHFCLOSE = 0x11A;
+static const uint16_t TC_FLASHDELETE = 0x11C;
+static const uint16_t TC_MODE_REPLAY = 0x11F;
+static const uint16_t TC_DOWNLINK_PWR_OFF = 0x124;
+static const uint16_t TM_MEMORY_READ_REPORT = 0x404;
+static const uint16_t ACK_SUCCESS = 0x400;
+static const uint16_t ACK_FAILURE = 0x401;
+static const uint16_t EXE_SUCCESS = 0x402;
+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
+ * 8.
+ */
+static const uint8_t SIZE_MEM_READ_RPT_FIX = 6;
+
+static const size_t MAX_FILENAME_SIZE = 256;
+
+/**
+ * PLOC space packet length for fixed size packets. This is the size of the whole packet data
+ * field. For the length field in the space packet this size will be substracted by one.
+ */
+static const uint16_t LENGTH_TC_MEM_WRITE = 12;
+static const uint16_t LENGTH_TC_MEM_READ = 8;
+
+static const size_t MAX_REPLY_SIZE = SpacePacket::PACKET_MAX_SIZE * 3;
+static const size_t MAX_COMMAND_SIZE = SpacePacket::PACKET_MAX_SIZE;
+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. (80 cycles * 0.5 seconds = 40 seconds).
+ */
+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:
+  // Initial length field of space packet. Will always be updated when packet is created.
+  static const uint16_t INIT_LENGTH = 1;
+
+  /**
+   * @brief    Constructor
+   *
+   * @param sequenceCount Sequence count of space packet which will be incremented with each
+   *        sent and received packets.
+   */
+  TcBase(uint16_t apid, uint16_t sequenceCount)
+      : SpacePacket(INIT_LENGTH, true, apid, sequenceCount) {}
+
+  /**
+   * @brief   Function to initialize the space packet
+   *
+   * @param commandData       Pointer to command specific data
+   * @param commandDataLen    Length of command data
+   *
+   * @return  RETURN_OK if packet creation was successful, otherwise error return value
+   */
+  virtual ReturnValue_t createPacket(const uint8_t* commandData, size_t commandDataLen) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = initPacket(commandData, commandDataLen);
+    if (result != HasReturnvaluesIF::HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    result = addCrc();
+    if (result != HasReturnvaluesIF::HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    return result;
+  }
+
+ protected:
+  /**
+   * @brief   Must be overwritten by the child class to define the command specific parameters
+   *
+   * @param commandData       Pointer to received command data
+   * @param commandDataLen    Length of received command data
+   */
+  virtual ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  /**
+   * @brief   Calculates and adds the CRC
+   */
+  ReturnValue_t addCrc() {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    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, 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;
+    }
+    return result;
+  }
+};
+
+/**
+ * @brief   Class for handling tm replies of the PLOC MPSoC.
+ */
+class TmPacket : public SpacePacket, public MPSoCReturnValuesIF {
+ public:
+  /**
+   * @brief   Constructor creates idle packet and sets length field to maximum allowed 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() - CRC_SIZE);
+    if (recalculatedCrc != receivedCrc) {
+      return CRC_FAILURE;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   This class helps to build the memory read command for the PLOC.
+ */
+class TcMemRead : public TcBase {
+ public:
+  /**
+   * @brief   Constructor
+   */
+  TcMemRead(uint16_t sequenceCount) : TcBase(apid::TC_MEM_READ, sequenceCount) {
+    this->setPacketDataLength(PACKET_LENGTH);
+  }
+
+  uint16_t getMemLen() const { return memLen; }
+
+ protected:
+  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = lengthCheck(commandDataLen);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    std::memcpy(this->localData.fields.buffer, commandData, MEM_ADDRESS_SIZE);
+    std::memcpy(this->localData.fields.buffer + MEM_ADDRESS_SIZE, commandData + MEM_ADDRESS_SIZE,
+                MEM_LEN_SIZE);
+    size_t size = sizeof(memLen);
+    const uint8_t* memLenPtr = commandData + MEM_ADDRESS_SIZE;
+    result =
+        SerializeAdapter::deSerialize(&memLen, &memLenPtr, &size, SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    return result;
+  }
+
+ private:
+  static const size_t COMMAND_LENGTH = 6;
+  static const size_t MEM_ADDRESS_SIZE = 4;
+  static const size_t MEM_LEN_SIZE = 2;
+  static const uint16_t PACKET_LENGTH = 7;
+
+  uint16_t memLen = 0;
+
+  ReturnValue_t lengthCheck(size_t commandDataLen) {
+    if (commandDataLen != COMMAND_LENGTH) {
+      return INVALID_LENGTH;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   This class helps to generate the space packet to write data to a memory address within
+ *          the PLOC.
+ */
+class TcMemWrite : public TcBase {
+ public:
+  /**
+   * @brief   Constructor
+   */
+  TcMemWrite(uint16_t sequenceCount) : TcBase(apid::TC_MEM_WRITE, sequenceCount) {}
+
+ protected:
+  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = lengthCheck(commandDataLen);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    std::memcpy(this->localData.fields.buffer, commandData, commandDataLen);
+    uint16_t memLen =
+        *(commandData + MEM_ADDRESS_SIZE) << 8 | *(commandData + MEM_ADDRESS_SIZE + 1);
+    this->setPacketDataLength(memLen * 4 + FIX_LENGTH - 1);
+    return result;
+  }
+
+ 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;
+  static const size_t FIX_LENGTH = 8;
+
+  ReturnValue_t lengthCheck(size_t commandDataLen) {
+    if (commandDataLen < MIN_COMMAND_DATA_LENGTH) {
+      sif::warning << "TcMemWrite: Command has invalid length " << commandDataLen << std::endl;
+      return INVALID_LENGTH;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   Class to help creation of flash fopen command.
+ */
+class FlashFopen : public TcBase {
+ public:
+  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_) {
+    accessMode = accessMode_;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    size_t nameSize = filename.size();
+    std::memcpy(this->getPacketData(), filename.c_str(), nameSize);
+    *(this->getPacketData() + nameSize) = NULL_TERMINATOR;
+    std::memcpy(this->getPacketData() + nameSize + sizeof(NULL_TERMINATOR), &accessMode,
+                sizeof(accessMode));
+    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 {
+ public:
+  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->getPacketData() + nameSize) = NULL_TERMINATOR;
+    this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1);
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    return result;
+  }
+};
+
+/**
+ * @brief   Class to build flash write space packet.
+ */
+class TcFlashWrite : public TcBase {
+ public:
+  TcFlashWrite(uint16_t sequenceCount) : TcBase(apid::TC_FLASHWRITE, sequenceCount) {}
+
+  ReturnValue_t createPacket(const uint8_t* writeData, uint32_t writeLen_) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    writeLen = writeLen_;
+    if (writeLen > MAX_DATA_SIZE) {
+      sif::debug << "FlashWrite::createPacket: Command data too big" << std::endl;
+      return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    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));
+    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 {
+ public:
+  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->getPacketData() + nameSize) = NULL_TERMINATOR;
+    this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1);
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    return result;
+  }
+};
+
+/**
+ * @brief   Class to build replay stop space packet.
+ */
+class TcReplayStop : public TcBase {
+ public:
+  TcReplayStop(uint16_t sequenceCount) : TcBase(apid::TC_REPLAY_STOP, sequenceCount) {}
+
+  ReturnValue_t createPacket() {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    this->setPacketDataLength(static_cast<uint16_t>(CRC_SIZE - 1));
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   This class helps to build the replay start command.
+ */
+class TcReplayStart : public TcBase {
+ public:
+  /**
+   * @brief   Constructor
+   */
+  TcReplayStart(uint16_t sequenceCount) : TcBase(apid::TC_REPLAY_START, sequenceCount) {}
+
+ protected:
+  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = lengthCheck(commandDataLen);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    result = checkData(*commandData);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    std::memcpy(this->localData.fields.buffer, commandData, commandDataLen);
+    this->setPacketDataLength(commandDataLen + CRC_SIZE - 1);
+    return result;
+  }
+
+ private:
+  static const size_t COMMAND_DATA_LENGTH = 1;
+  static const uint8_t REPEATING = 0;
+  static const uint8_t ONCE = 1;
+
+  ReturnValue_t lengthCheck(size_t commandDataLen) {
+    if (commandDataLen != COMMAND_DATA_LENGTH) {
+      sif::warning << "TcReplayStart: Command has invalid length " << commandDataLen << std::endl;
+      return INVALID_LENGTH;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  ReturnValue_t checkData(uint8_t replay) {
+    if (replay != REPEATING && replay != ONCE) {
+      sif::warning << "TcReplayStart::checkData: Invalid replay value" << std::endl;
+      return INVALID_PARAMETER;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   This class helps to build downlink power on command.
+ */
+class TcDownlinkPwrOn : public TcBase {
+ public:
+  /**
+   * @brief   Constructor
+   */
+  TcDownlinkPwrOn(uint16_t sequenceCount) : TcBase(apid::TC_DOWNLINK_PWR_ON, sequenceCount) {}
+
+ protected:
+  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = lengthCheck(commandDataLen);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    result = modeCheck(*commandData);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    result = laneRateCheck(*(commandData + 1));
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    std::memcpy(this->localData.fields.buffer, commandData, commandDataLen);
+    std::memcpy(this->localData.fields.buffer + commandDataLen, &MAX_AMPLITUDE,
+                sizeof(MAX_AMPLITUDE));
+    this->setPacketDataLength(commandDataLen + sizeof(MAX_AMPLITUDE) + CRC_SIZE - 1);
+    return result;
+  }
+
+ private:
+  static const uint8_t INTERFACE_ID = CLASS_ID::DWLPWRON_CMD;
+
+  //! [EXPORT] : [COMMENT] Received command has invalid JESD mode (valid modes are 0 - 5)
+  static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0xE0);
+  //! [EXPORT] : [COMMENT] Received command has invalid lane rate (valid lane rate are 0 - 9)
+  static const ReturnValue_t INVALID_LANE_RATE = MAKE_RETURN_CODE(0xE1);
+
+  static const size_t COMMAND_DATA_LENGTH = 2;
+  static const uint8_t MAX_MODE = 5;
+  static const uint8_t MAX_LANE_RATE = 9;
+  static const uint16_t MAX_AMPLITUDE = 0;
+
+  ReturnValue_t lengthCheck(size_t commandDataLen) {
+    if (commandDataLen != COMMAND_DATA_LENGTH) {
+      sif::warning << "TcDownlinkPwrOn: Command has invalid length " << commandDataLen << std::endl;
+      return INVALID_LENGTH;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  ReturnValue_t modeCheck(uint8_t mode) {
+    if (mode > MAX_MODE) {
+      sif::warning << "TcDwonlinkPwrOn::modeCheck: Invalid JESD mode" << std::endl;
+      return INVALID_MODE;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  ReturnValue_t laneRateCheck(uint8_t laneRate) {
+    if (laneRate > MAX_LANE_RATE) {
+      sif::warning << "TcReplayStart::laneRateCheck: Invalid lane rate" << std::endl;
+      return INVALID_LANE_RATE;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   Class to build replay stop space packet.
+ */
+class TcDownlinkPwrOff : public TcBase {
+ public:
+  TcDownlinkPwrOff(uint16_t sequenceCount) : TcBase(apid::TC_DOWNLINK_PWR_OFF, sequenceCount) {}
+
+  ReturnValue_t createPacket() {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    this->setPacketDataLength(static_cast<uint16_t>(CRC_SIZE - 1));
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   This class helps to build the replay start command.
+ */
+class TcReplayWriteSeq : public TcBase {
+ public:
+  /**
+   * @brief   Constructor
+   */
+  TcReplayWriteSeq(uint16_t sequenceCount)
+      : TcBase(apid::TC_REPLAY_WRITE_SEQUENCE, sequenceCount) {}
+
+ protected:
+  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = lengthCheck(commandDataLen);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    std::memcpy(this->localData.fields.buffer, commandData, commandDataLen);
+    *(this->localData.fields.buffer + commandDataLen) = NULL_TERMINATOR;
+    this->setPacketDataLength(commandDataLen + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1);
+    return result;
+  }
+
+ 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;
+      return INVALID_LENGTH;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+class FlashWritePusCmd : public MPSoCReturnValuesIF {
+ public:
+  FlashWritePusCmd(){};
+
+  ReturnValue_t extractFields(const uint8_t* commandData, size_t commandDataLen) {
+    if (commandDataLen > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE + MAX_FILENAME_SIZE)) {
+      return INVALID_LENGTH;
+    }
+    obcFile = std::string(reinterpret_cast<const char*>(commandData));
+    if (obcFile.size() > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE)) {
+      return FILENAME_TOO_LONG;
+    }
+    mpsocFile = std::string(
+        reinterpret_cast<const char*>(commandData + obcFile.size() + SIZE_NULL_TERMINATOR));
+    if (mpsocFile.size() > MAX_FILENAME_SIZE) {
+      return MPSOC_FILENAME_TOO_LONG;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  std::string getObcFile() { return obcFile; }
+
+  std::string getMPSoCFile() { return mpsocFile; }
+
+ private:
+  static const size_t SIZE_NULL_TERMINATOR = 1;
+  std::string obcFile = "";
+  std::string mpsocFile = "";
+};
+
+/**
+ * @brief   Class to build replay stop space packet.
+ */
+class TcModeReplay : public TcBase {
+ public:
+  TcModeReplay(uint16_t sequenceCount) : TcBase(apid::TC_MODE_REPLAY, sequenceCount) {}
+
+  ReturnValue_t createPacket() {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    this->setPacketDataLength(static_cast<uint16_t>(CRC_SIZE - 1));
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+}  // namespace mpsoc
+
+#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ */

linux/devices/ploc/CMakeLists.txt

@@ -2,4 +2,6 @@ target_sources(${OBSW_NAME} PRIVATE
     PlocSupervisorHandler.cpp
     PlocUpdater.cpp
     PlocMemoryDumper.cpp
-)
+    PlocMPSoCHandler.cpp
+    PlocMPSoCHelper.cpp
+)

linux/devices/ploc/PlocMPSoCHandler.cpp

@@ -0,0 +1,766 @@
+#include "PlocMPSoCHandler.h"
+
+#include "OBSWConfig.h"
+#include "fsfw/datapool/PoolReadGuard.h"
+#include "fsfw/globalfunctions/CRC.h"
+
+PlocMPSoCHandler::PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid,
+                                   CookieIF* comCookie, PlocMPSoCHelper* plocMPSoCHelper,
+                                   Gpio uartIsolatorSwitch)
+    : DeviceHandlerBase(objectId, uartComIFid, comCookie),
+      plocMPSoCHelper(plocMPSoCHelper),
+      uartIsolatorSwitch(uartIsolatorSwitch) {
+  if (comCookie == nullptr) {
+    sif::error << "PlocMPSoCHandler: Invalid communication cookie" << std::endl;
+  }
+  eventQueue = QueueFactory::instance()->createMessageQueue(EventMessage::EVENT_MESSAGE_SIZE * 5);
+}
+
+PlocMPSoCHandler::~PlocMPSoCHandler() {}
+
+ReturnValue_t PlocMPSoCHandler::initialize() {
+  ReturnValue_t result = RETURN_OK;
+  result = DeviceHandlerBase::initialize();
+  if (result != RETURN_OK) {
+    return result;
+  }
+  uartComIf = dynamic_cast<UartComIF*>(communicationInterface);
+  if (uartComIf == nullptr) {
+    sif::warning << "PlocMPSoCHandler::initialize: Invalid uart com if" << std::endl;
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+
+  EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
+  if (manager == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << "PlocMPSoCHandler::initialize: Invalid event manager" << std::endl;
+#endif
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+    ;
+  }
+  result = manager->registerListener(eventQueue->getId());
+  if (result != RETURN_OK) {
+    return result;
+  }
+  result = manager->subscribeToEventRange(
+      eventQueue->getId(), event::getEventId(PlocMPSoCHelper::MPSOC_FLASH_WRITE_FAILED),
+      event::getEventId(PlocMPSoCHelper::MPSOC_FLASH_WRITE_SUCCESSFUL));
+  if (result != RETURN_OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << "PlocMPSoCHandler::initialize: Failed to subscribe to events from "
+                    " ploc mpsoc helper"
+                 << std::endl;
+#endif
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+
+  result = plocMPSoCHelper->setComIF(communicationInterface);
+  if (result != RETURN_OK) {
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+  plocMPSoCHelper->setComCookie(comCookie);
+  plocMPSoCHelper->setSequenceCount(&sequenceCount);
+  return result;
+}
+
+void PlocMPSoCHandler::performOperationHook() {
+  EventMessage event;
+  for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == RETURN_OK;
+       result = eventQueue->receiveMessage(&event)) {
+    switch (event.getMessageId()) {
+      case EventMessage::EVENT_MESSAGE:
+        handleEvent(&event);
+        break;
+      default:
+        sif::debug << "PlocMPSoCHandler::performOperationHook: Did not subscribe to this event"
+                   << " message" << std::endl;
+        break;
+    }
+  }
+}
+
+ReturnValue_t PlocMPSoCHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                                              const uint8_t* data, size_t size) {
+  ReturnValue_t result = RETURN_OK;
+
+  if (plocMPSoCHelperExecuting) {
+    return MPSoCReturnValuesIF::MPSOC_HELPER_EXECUTING;
+  }
+
+  switch (actionId) {
+    case mpsoc::TC_FLASHWRITE: {
+      if (size > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
+        return MPSoCReturnValuesIF::FILENAME_TOO_LONG;
+      }
+      mpsoc::FlashWritePusCmd flashWritePusCmd;
+      result = flashWritePusCmd.extractFields(data, size);
+      if (result != RETURN_OK) {
+        return result;
+      }
+      result = plocMPSoCHelper->startFlashWrite(flashWritePusCmd.getObcFile(),
+                                                flashWritePusCmd.getMPSoCFile());
+      if (result != RETURN_OK) {
+        return result;
+      }
+      plocMPSoCHelperExecuting = true;
+      return EXECUTION_FINISHED;
+    }
+    case (mpsoc::OBSW_RESET_SEQ_COUNT): {
+      sequenceCount = 0;
+      return EXECUTION_FINISHED;
+    }
+    default:
+      break;
+  }
+  return DeviceHandlerBase::executeAction(actionId, commandedBy, data, size);
+}
+
+void PlocMPSoCHandler::doStartUp() {
+#if OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP == 1
+  setMode(MODE_NORMAL);
+#else
+  setMode(_MODE_TO_ON);
+#endif
+  uartIsolatorSwitch.pullHigh();
+}
+
+void PlocMPSoCHandler::doShutDown() {
+  uartIsolatorSwitch.pullLow();
+  setMode(_MODE_POWER_DOWN);
+}
+
+ReturnValue_t PlocMPSoCHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PlocMPSoCHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                        const uint8_t* commandData,
+                                                        size_t commandDataLen) {
+  ReturnValue_t result = RETURN_OK;
+  switch (deviceCommand) {
+    case (mpsoc::TC_MEM_WRITE): {
+      result = prepareTcMemWrite(commandData, commandDataLen);
+      break;
+    }
+    case (mpsoc::TC_MEM_READ): {
+      result = prepareTcMemRead(commandData, commandDataLen);
+      break;
+    }
+    case (mpsoc::TC_FLASHDELETE): {
+      result = prepareTcFlashDelete(commandData, commandDataLen);
+      break;
+    }
+    case (mpsoc::TC_REPLAY_START): {
+      result = prepareTcReplayStart(commandData, commandDataLen);
+      break;
+    }
+    case (mpsoc::TC_REPLAY_STOP): {
+      result = prepareTcReplayStop();
+      break;
+    }
+    case (mpsoc::TC_DOWNLINK_PWR_ON): {
+      result = prepareTcDownlinkPwrOn(commandData, commandDataLen);
+      break;
+    }
+    case (mpsoc::TC_DOWNLINK_PWR_OFF): {
+      result = prepareTcDownlinkPwrOff();
+      break;
+    }
+    case (mpsoc::TC_REPLAY_WRITE_SEQUENCE): {
+      result = prepareTcReplayWriteSequence(commandData, commandDataLen);
+      break;
+    }
+    case (mpsoc::TC_MODE_REPLAY): {
+      result = prepareTcModeReplay();
+      break;
+    }
+    default:
+      sif::debug << "PlocMPSoCHandler::buildCommandFromCommand: Command not implemented"
+                 << std::endl;
+      result = DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
+      break;
+  }
+
+  if (result == RETURN_OK) {
+    /**
+     * Flushing the receive buffer to make sure there are no data left from a faulty reply.
+     */
+    uartComIf->flushUartRxBuffer(comCookie);
+  }
+
+  return result;
+}
+
+void PlocMPSoCHandler::fillCommandAndReplyMap() {
+  this->insertInCommandMap(mpsoc::TC_MEM_WRITE);
+  this->insertInCommandMap(mpsoc::TC_MEM_READ);
+  this->insertInCommandMap(mpsoc::TC_FLASHDELETE);
+  this->insertInCommandMap(mpsoc::TC_REPLAY_START);
+  this->insertInCommandMap(mpsoc::TC_REPLAY_STOP);
+  this->insertInCommandMap(mpsoc::TC_DOWNLINK_PWR_ON);
+  this->insertInCommandMap(mpsoc::TC_DOWNLINK_PWR_OFF);
+  this->insertInCommandMap(mpsoc::TC_REPLAY_WRITE_SEQUENCE);
+  this->insertInCommandMap(mpsoc::TC_MODE_REPLAY);
+  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);
+}
+
+ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remainingSize,
+                                             DeviceCommandId_t* foundId, size_t* foundLen) {
+  ReturnValue_t result = RETURN_OK;
+
+  uint16_t apid = (*(start) << 8 | *(start + 1)) & APID_MASK;
+
+  switch (apid) {
+    case (mpsoc::apid::ACK_SUCCESS):
+      *foundLen = mpsoc::SIZE_ACK_REPORT;
+      *foundId = mpsoc::ACK_REPORT;
+      break;
+    case (mpsoc::apid::ACK_FAILURE):
+      *foundLen = mpsoc::SIZE_ACK_REPORT;
+      *foundId = mpsoc::ACK_REPORT;
+      break;
+    case (mpsoc::apid::TM_MEMORY_READ_REPORT):
+      *foundLen = tmMemReadReport.rememberRequestedSize;
+      *foundId = mpsoc::TM_MEMORY_READ_REPORT;
+      break;
+    case (mpsoc::apid::EXE_SUCCESS):
+      *foundLen = mpsoc::SIZE_EXE_REPORT;
+      *foundId = mpsoc::EXE_REPORT;
+      break;
+    case (mpsoc::apid::EXE_FAILURE):
+      *foundLen = mpsoc::SIZE_EXE_REPORT;
+      *foundId = mpsoc::EXE_REPORT;
+      break;
+    default: {
+      sif::debug << "PlocMPSoCHandler::scanForReply: Reply has invalid apid" << std::endl;
+      *foundLen = remainingSize;
+      return MPSoCReturnValuesIF::INVALID_APID;
+    }
+  }
+  sequenceCount++;
+  uint16_t recvSeqCnt = (*(start + 2) << 8 | *(start + 3)) & PACKET_SEQUENCE_COUNT_MASK;
+  if (recvSeqCnt != sequenceCount) {
+    triggerEvent(MPSOC_HANDLER_SEQ_CNT_MISMATCH, sequenceCount, recvSeqCnt);
+    sequenceCount = recvSeqCnt;
+  }
+  return result;
+}
+
+ReturnValue_t PlocMPSoCHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
+  ReturnValue_t result = RETURN_OK;
+
+  switch (id) {
+    case mpsoc::ACK_REPORT: {
+      result = handleAckReport(packet);
+      break;
+    }
+    case (mpsoc::TM_MEMORY_READ_REPORT): {
+      result = handleMemoryReadReport(packet);
+      break;
+    }
+    case (mpsoc::EXE_REPORT): {
+      result = handleExecutionReport(packet);
+      break;
+    }
+    default: {
+      sif::debug << "PlocMPSoCHandler::interpretDeviceReply: Unknown device reply id" << std::endl;
+      return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
+    }
+  }
+
+  return result;
+}
+
+void PlocMPSoCHandler::setNormalDatapoolEntriesInvalid() {}
+
+uint32_t PlocMPSoCHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t PlocMPSoCHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                        LocalDataPoolManager& poolManager) {
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+void PlocMPSoCHandler::handleEvent(EventMessage* eventMessage) {
+  object_id_t objectId = eventMessage->getReporter();
+  switch (objectId) {
+    case objects::PLOC_MPSOC_HELPER: {
+      plocMPSoCHelperExecuting = false;
+      break;
+    }
+    default:
+      sif::debug << "PlocMPSoCHandler::handleEvent: Did not subscribe to this event" << std::endl;
+      break;
+  }
+}
+
+ReturnValue_t PlocMPSoCHandler::prepareTcMemWrite(const uint8_t* commandData,
+                                                  size_t commandDataLen) {
+  ReturnValue_t result = RETURN_OK;
+  sequenceCount++;
+  mpsoc::TcMemWrite tcMemWrite(sequenceCount);
+  result = tcMemWrite.createPacket(commandData, commandDataLen);
+  if (result != RETURN_OK) {
+    sequenceCount--;
+    return result;
+  }
+  copyToCommandBuffer(&tcMemWrite);
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHandler::prepareTcMemRead(const uint8_t* commandData,
+                                                 size_t commandDataLen) {
+  ReturnValue_t result = RETURN_OK;
+  sequenceCount++;
+  mpsoc::TcMemRead tcMemRead(sequenceCount);
+  result = tcMemRead.createPacket(commandData, commandDataLen);
+  if (result != RETURN_OK) {
+    sequenceCount--;
+    return result;
+  }
+  copyToCommandBuffer(&tcMemRead);
+  tmMemReadReport.rememberRequestedSize = tcMemRead.getMemLen() * 4 + TmMemReadReport::FIX_SIZE;
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHandler::prepareTcFlashDelete(const uint8_t* commandData,
+                                                     size_t commandDataLen) {
+  if (commandDataLen > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
+    return NAME_TOO_LONG;
+  }
+  ReturnValue_t result = RETURN_OK;
+  sequenceCount++;
+  mpsoc::TcFlashDelete tcFlashDelete(sequenceCount);
+  result = tcFlashDelete.createPacket(
+      std::string(reinterpret_cast<const char*>(commandData), commandDataLen));
+  if (result != RETURN_OK) {
+    sequenceCount--;
+    return result;
+  }
+  copyToCommandBuffer(&tcFlashDelete);
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHandler::prepareTcReplayStart(const uint8_t* commandData,
+                                                     size_t commandDataLen) {
+  ReturnValue_t result = RETURN_OK;
+  sequenceCount++;
+  mpsoc::TcReplayStart tcReplayStart(sequenceCount);
+  result = tcReplayStart.createPacket(commandData, commandDataLen);
+  if (result != RETURN_OK) {
+    sequenceCount--;
+    return result;
+  }
+  copyToCommandBuffer(&tcReplayStart);
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHandler::prepareTcReplayStop() {
+  ReturnValue_t result = RETURN_OK;
+  sequenceCount++;
+  mpsoc::TcReplayStop tcReplayStop(sequenceCount);
+  result = tcReplayStop.createPacket();
+  if (result != RETURN_OK) {
+    sequenceCount--;
+    return result;
+  }
+  copyToCommandBuffer(&tcReplayStop);
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOn(const uint8_t* commandData,
+                                                       size_t commandDataLen) {
+  ReturnValue_t result = RETURN_OK;
+  sequenceCount++;
+  mpsoc::TcDownlinkPwrOn tcDownlinkPwrOn(sequenceCount);
+  result = tcDownlinkPwrOn.createPacket(commandData, commandDataLen);
+  if (result != RETURN_OK) {
+    sequenceCount--;
+    return result;
+  }
+  copyToCommandBuffer(&tcDownlinkPwrOn);
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOff() {
+  ReturnValue_t result = RETURN_OK;
+  sequenceCount++;
+  mpsoc::TcDownlinkPwrOff tcDownlinkPwrOff(sequenceCount);
+  result = tcDownlinkPwrOff.createPacket();
+  if (result != RETURN_OK) {
+    sequenceCount--;
+    return result;
+  }
+  copyToCommandBuffer(&tcDownlinkPwrOff);
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* commandData,
+                                                             size_t commandDataLen) {
+  ReturnValue_t result = RETURN_OK;
+  sequenceCount++;
+  mpsoc::TcReplayWriteSeq tcReplayWriteSeq(sequenceCount);
+  result = tcReplayWriteSeq.createPacket(commandData, commandDataLen);
+  if (result != RETURN_OK) {
+    sequenceCount--;
+    return result;
+  }
+  copyToCommandBuffer(&tcReplayWriteSeq);
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHandler::prepareTcModeReplay() {
+  ReturnValue_t result = RETURN_OK;
+  sequenceCount++;
+  mpsoc::TcModeReplay tcModeReplay(sequenceCount);
+  result = tcModeReplay.createPacket();
+  if (result != RETURN_OK) {
+    sequenceCount--;
+    return result;
+  }
+  memcpy(commandBuffer, tcModeReplay.getWholeData(), tcModeReplay.getFullSize());
+  rawPacket = commandBuffer;
+  rawPacketLen = tcModeReplay.getFullSize();
+  nextReplyId = mpsoc::ACK_REPORT;
+  return RETURN_OK;
+}
+
+void PlocMPSoCHandler::copyToCommandBuffer(mpsoc::TcBase* tc) {
+  if (tc == nullptr) {
+    sif::debug << "PlocMPSoCHandler::copyToCommandBuffer: Invalid TC" << std::endl;
+  }
+  memcpy(commandBuffer, tc->getWholeData(), tc->getFullSize());
+  rawPacket = commandBuffer;
+  rawPacketLen = tc->getFullSize();
+  nextReplyId = mpsoc::ACK_REPORT;
+}
+
+ReturnValue_t PlocMPSoCHandler::verifyPacket(const uint8_t* start, size_t foundLen) {
+  uint16_t receivedCrc = *(start + foundLen - 2) << 8 | *(start + foundLen - 1);
+  uint16_t recalculatedCrc = CRC::crc16ccitt(start, foundLen - 2);
+  if (receivedCrc != recalculatedCrc) {
+    return MPSoCReturnValuesIF::CRC_FAILURE;
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHandler::handleAckReport(const uint8_t* data) {
+  ReturnValue_t result = RETURN_OK;
+
+  result = verifyPacket(data, mpsoc::SIZE_ACK_REPORT);
+  if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
+    sif::warning << "PlocMPSoCHandler::handleAckReport: CRC failure" << std::endl;
+    nextReplyId = mpsoc::NONE;
+    replyRawReplyIfnotWiretapped(data, mpsoc::SIZE_ACK_REPORT);
+    triggerEvent(MPSOC_HANDLER_CRC_FAILURE);
+    sendFailureReport(mpsoc::ACK_REPORT, MPSoCReturnValuesIF::CRC_FAILURE);
+    disableAllReplies();
+    return IGNORE_REPLY_DATA;
+  }
+
+  uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK;
+
+  switch (apid) {
+    case mpsoc::apid::ACK_FAILURE: {
+      // TODO: Interpretation of status field in acknowledgment report
+      sif::debug << "PlocMPSoCHandler::handleAckReport: Received Ack failure report" << std::endl;
+      DeviceCommandId_t commandId = getPendingCommand();
+      uint16_t status = getStatus(data);
+      if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
+        triggerEvent(ACK_FAILURE, commandId, status);
+      }
+      sendFailureReport(mpsoc::ACK_REPORT, MPSoCReturnValuesIF::RECEIVED_ACK_FAILURE);
+      disableAllReplies();
+      nextReplyId = mpsoc::NONE;
+      result = IGNORE_REPLY_DATA;
+      break;
+    }
+    case mpsoc::apid::ACK_SUCCESS: {
+      setNextReplyId();
+      break;
+    }
+    default: {
+      sif::debug << "PlocMPSoCHandler::handleAckReport: Invalid APID in Ack report" << std::endl;
+      result = RETURN_FAILED;
+      break;
+    }
+  }
+
+  return result;
+}
+
+ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) {
+  ReturnValue_t result = RETURN_OK;
+
+  result = verifyPacket(data, mpsoc::SIZE_EXE_REPORT);
+  if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
+    sif::warning << "PlocMPSoCHandler::handleExecutionReport: CRC failure" << std::endl;
+    nextReplyId = mpsoc::NONE;
+    return result;
+  }
+
+  uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK;
+
+  switch (apid) {
+    case (mpsoc::apid::EXE_SUCCESS): {
+      break;
+    }
+    case (mpsoc::apid::EXE_FAILURE): {
+      // TODO: Interpretation of status field in execution report
+      sif::warning << "PlocMPSoCHandler::handleExecutionReport: Received execution failure report"
+                   << std::endl;
+      DeviceCommandId_t commandId = getPendingCommand();
+      if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
+        uint16_t status = getStatus(data);
+        triggerEvent(EXE_FAILURE, commandId, status);
+      } else {
+        sif::debug << "PlocMPSoCHandler::handleExecutionReport: Unknown command id" << std::endl;
+      }
+      printStatus(data);
+      sendFailureReport(mpsoc::EXE_REPORT, MPSoCReturnValuesIF::RECEIVED_EXE_FAILURE);
+      disableExeReportReply();
+      result = IGNORE_REPLY_DATA;
+      break;
+    }
+    default: {
+      sif::warning << "PlocMPSoCHandler::handleExecutionReport: Unknown APID" << std::endl;
+      result = RETURN_FAILED;
+      break;
+    }
+  }
+  nextReplyId = mpsoc::NONE;
+  return result;
+}
+
+ReturnValue_t PlocMPSoCHandler::handleMemoryReadReport(const uint8_t* data) {
+  ReturnValue_t result = RETURN_OK;
+  result = verifyPacket(data, tmMemReadReport.rememberRequestedSize);
+  if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
+    sif::warning << "PlocMPSoCHandler::handleMemoryReadReport: Memory read report has invalid crc"
+                 << std::endl;
+  }
+  uint16_t memLen =
+      *(data + mpsoc::MEM_READ_RPT_LEN_OFFSET) << 8 | *(data + mpsoc::MEM_READ_RPT_LEN_OFFSET + 1);
+  /** Send data to commanding queue */
+  handleDeviceTM(data + mpsoc::DATA_FIELD_OFFSET, mpsoc::SIZE_MEM_READ_RPT_FIX + memLen * 4,
+                 mpsoc::TM_MEMORY_READ_REPORT);
+  nextReplyId = mpsoc::EXE_REPORT;
+  return result;
+}
+
+ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator command,
+                                                      uint8_t expectedReplies, bool useAlternateId,
+                                                      DeviceCommandId_t alternateReplyID) {
+  ReturnValue_t result = RETURN_OK;
+
+  uint8_t enabledReplies = 0;
+
+  switch (command->first) {
+    case mpsoc::TC_MEM_WRITE:
+    case mpsoc::TC_FLASHDELETE:
+    case mpsoc::TC_REPLAY_START:
+    case mpsoc::TC_REPLAY_STOP:
+    case mpsoc::TC_DOWNLINK_PWR_ON:
+    case mpsoc::TC_DOWNLINK_PWR_OFF:
+    case mpsoc::TC_REPLAY_WRITE_SEQUENCE:
+    case mpsoc::TC_MODE_REPLAY:
+      enabledReplies = 2;
+      break;
+    case mpsoc::TC_MEM_READ: {
+      enabledReplies = 3;
+      result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
+                                                        mpsoc::TM_MEMORY_READ_REPORT);
+      if (result != RETURN_OK) {
+        sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id "
+                   << mpsoc::TM_MEMORY_READ_REPORT << " not in replyMap" << std::endl;
+      }
+      break;
+    }
+    case mpsoc::OBSW_RESET_SEQ_COUNT:
+      break;
+    default:
+      sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Unknown command id" << std::endl;
+      break;
+  }
+
+  /**
+   * Every command causes at least one acknowledgment and one execution report. Therefore both
+   * replies will be enabled here.
+   */
+  result =
+      DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, mpsoc::ACK_REPORT);
+  if (result != RETURN_OK) {
+    sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id " << mpsoc::ACK_REPORT
+               << " not in replyMap" << std::endl;
+  }
+
+  result =
+      DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, mpsoc::EXE_REPORT);
+  if (result != RETURN_OK) {
+    sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id " << mpsoc::EXE_REPORT
+               << " not in replyMap" << std::endl;
+  }
+
+  switch (command->first) {
+    case mpsoc::TC_REPLAY_WRITE_SEQUENCE: {
+      DeviceReplyIter iter = deviceReplyMap.find(mpsoc::EXE_REPORT);
+      // 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;
+      break;
+    }
+    case mpsoc::TC_DOWNLINK_PWR_ON: {
+      DeviceReplyIter iter = deviceReplyMap.find(mpsoc::EXE_REPORT);
+      //
+      iter->second.delayCycles = mpsoc::TC_DOWNLINK_PWR_ON;
+      break;
+    }
+    default:
+      break;
+  }
+
+  return RETURN_OK;
+}
+
+void PlocMPSoCHandler::setNextReplyId() {
+  switch (getPendingCommand()) {
+    case mpsoc::TC_MEM_READ:
+      nextReplyId = mpsoc::TM_MEMORY_READ_REPORT;
+      break;
+    default:
+      /* If no telemetry is expected the next reply is always the execution report */
+      nextReplyId = mpsoc::EXE_REPORT;
+      break;
+  }
+}
+size_t PlocMPSoCHandler::getNextReplyLength(DeviceCommandId_t commandId) {
+  size_t replyLen = 0;
+
+  if (nextReplyId == mpsoc::NONE) {
+    return replyLen;
+  }
+
+  DeviceReplyIter iter = deviceReplyMap.find(nextReplyId);
+
+  if (iter != deviceReplyMap.end()) {
+    if (iter->second.delayCycles == 0) {
+      /* Reply inactive */
+      return replyLen;
+    }
+    switch (nextReplyId) {
+      case mpsoc::TM_MEMORY_READ_REPORT: {
+        replyLen = tmMemReadReport.rememberRequestedSize;
+        break;
+      }
+      default: {
+        replyLen = iter->second.replyLen;
+        break;
+      }
+    }
+  } else {
+    sif::debug << "PlocMPSoCHandler::getNextReplyLength: No entry for reply with reply id "
+               << std::hex << nextReplyId << " in deviceReplyMap" << std::endl;
+  }
+
+  return replyLen;
+}
+
+void PlocMPSoCHandler::handleDeviceTM(const uint8_t* data, size_t dataSize,
+                                      DeviceCommandId_t replyId) {
+  ReturnValue_t result = RETURN_OK;
+
+  if (wiretappingMode == RAW) {
+    /* Data already sent in doGetRead() */
+    return;
+  }
+
+  DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
+  if (iter == deviceReplyMap.end()) {
+    sif::debug << "PlocMPSoCHandler::handleDeviceTM: Unknown reply id" << std::endl;
+    return;
+  }
+  MessageQueueId_t queueId = iter->second.command->second.sendReplyTo;
+
+  if (queueId == NO_COMMANDER) {
+    return;
+  }
+
+  result = actionHelper.reportData(queueId, replyId, data, dataSize);
+  if (result != RETURN_OK) {
+    sif::debug << "PlocMPSoCHandler::handleDeviceTM: Failed to report data" << std::endl;
+  }
+}
+
+void PlocMPSoCHandler::disableAllReplies() {
+  DeviceReplyMap::iterator iter;
+
+  /* Disable ack reply */
+  iter = deviceReplyMap.find(mpsoc::ACK_REPORT);
+  DeviceReplyInfo* info = &(iter->second);
+  info->delayCycles = 0;
+  info->command = deviceCommandMap.end();
+
+  DeviceCommandId_t commandId = getPendingCommand();
+
+  /* If the command expects a telemetry packet the appropriate tm reply will be disabled here */
+  switch (commandId) {
+    case mpsoc::TC_MEM_WRITE:
+      break;
+    case mpsoc::TC_MEM_READ: {
+      iter = deviceReplyMap.find(mpsoc::TM_MEMORY_READ_REPORT);
+      info = &(iter->second);
+      info->delayCycles = 0;
+      info->command = deviceCommandMap.end();
+      break;
+    }
+    default: {
+      sif::debug << "PlocMPSoCHandler::disableAllReplies: Unknown command id" << commandId
+                 << std::endl;
+      break;
+    }
+  }
+
+  /* We must always disable the execution report reply here */
+  disableExeReportReply();
+  nextReplyId = mpsoc::NONE;
+}
+
+void PlocMPSoCHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status) {
+  DeviceReplyIter iter = deviceReplyMap.find(replyId);
+  if (iter == deviceReplyMap.end()) {
+    sif::debug << "PlocMPSoCHandler::sendFailureReport: Reply not in reply map" << std::endl;
+    return;
+  }
+  DeviceCommandInfo* info = &(iter->second.command->second);
+  if (info == nullptr) {
+    sif::debug << "PlocMPSoCHandler::sendFailureReport: Reply has no active command" << std::endl;
+    return;
+  }
+  if (info->sendReplyTo != NO_COMMANDER) {
+    actionHelper.finish(false, info->sendReplyTo, iter->first, status);
+  }
+  info->isExecuting = false;
+}
+
+void PlocMPSoCHandler::disableExeReportReply() {
+  DeviceReplyIter iter = deviceReplyMap.find(mpsoc::EXE_REPORT);
+  DeviceReplyInfo* info = &(iter->second);
+  info->delayCycles = 0;
+  info->command = deviceCommandMap.end();
+  /* Expected replies is set to one here. The value will be set to 0 in replyToReply() */
+  info->command->second.expectedReplies = 0;
+}
+
+void PlocMPSoCHandler::printStatus(const uint8_t* data) {
+  uint16_t status = *(data + STATUS_OFFSET) << 8 | *(data + STATUS_OFFSET + 1);
+  sif::info << "Verification report status: 0x" << std::hex << status << std::endl;
+}
+
+uint16_t PlocMPSoCHandler::getStatus(const uint8_t* data) {
+  return *(data + STATUS_OFFSET) << 8 | *(data + STATUS_OFFSET + 1);
+}

linux/devices/ploc/PlocMPSoCHandler.h

@@ -1,33 +1,40 @@
-#ifndef MISSION_DEVICES_PLOCMPSOCHANDLER_H_
+#ifndef BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_
-#define MISSION_DEVICES_PLOCMPSOCHANDLER_H_
+#define BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_
 
-#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <string>
-#include <mission/devices/devicedefinitions/PlocMPSoCDefinitions.h>
 
-#include <cstring>
+#include "PlocMPSoCHelper.h"
+#include "fsfw/devicehandlers/DeviceHandlerBase.h"
+#include "fsfw/ipc/QueueFactory.h"
+#include "fsfw/tmtcservices/SourceSequenceCounter.h"
+#include "fsfw_hal/linux/gpio/Gpio.h"
+#include "fsfw_hal/linux/uart/UartComIF.h"
+#include "linux/devices/devicedefinitions/MPSoCReturnValuesIF.h"
+#include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 
 /**
- * @brief	This is the device handler for the MPSoC which is programmed by the ILH of the
+ * @brief	This is the device handler for the MPSoC of the payload computer.
- *          university of stuttgart.
+ *
+ * @details The PLOC uses the space packet protocol for communication. Each command will be
+ *          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 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 otherwise the MPSoC will reply with an acknowledgment failure report.
  *
- * @details
- * The PLOC uses the space packet protocol for communication. To each command the PLOC
- * answers with at least one acknowledgment and one execution report.
- * Flight manual:
- * https://egit.irs.uni-stuttgart.de/redmine/projects/eive-flight-manual/wiki/PLOC_Commands
- * ILH ICD: https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/
- *          Arbeitsdaten/08_Used%20Components/PLOC&fileid=940960
  * @author	J. Meier
  */
 class PlocMPSoCHandler : public DeviceHandlerBase {
  public:
-  PlocMPSoCHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie);
+  PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie,
+                   PlocMPSoCHelper* plocMPSoCHelper, Gpio uartIsolatorSwitch);
   virtual ~PlocMPSoCHandler();
-
+  virtual ReturnValue_t initialize() override;
-  /**
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-   * @brief   Sets mode to MODE_NORMAL. Can be used for debugging.
+                              const uint8_t* data, size_t size) override;
-   */
+  void performOperationHook() override;
-  void setModeNormal();
 
  protected:
   void doStartUp() override;
@@ -50,71 +57,78 @@ class PlocMPSoCHandler : public DeviceHandlerBase {
   size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
 
  private:
-  static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MPSOC_HANDLER;
-
-  //! Space Packet received from PLOC has invalid CRC
-  static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0);
-  //! Received ACK failure reply from PLOC
-  static const ReturnValue_t RECEIVED_ACK_FAILURE = MAKE_RETURN_CODE(0xA1);
-  //! Received execution failure reply from PLOC
-  static const ReturnValue_t RECEIVED_EXE_FAILURE = MAKE_RETURN_CODE(0xA2);
-  //! Received space packet with invalid APID from PLOC
-  static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3);
-
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HANDLER;
 
-  //! PLOC crc failure in telemetry packet
+  //! [EXPORT] : [COMMENT] PLOC crc failure in telemetry packet
   static const Event MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW);
-  //! PLOC receive acknowledgment failure report
+  //! [EXPORT] : [COMMENT] PLOC receive acknowledgment failure report
+  //! P1: Command Id which leads the acknowledgment failure report
+  //! P2: The status field inserted by the MPSoC into the data field
   static const Event ACK_FAILURE = MAKE_EVENT(2, severity::LOW);
-  //! PLOC receive execution failure report
+  //! [EXPORT] : [COMMENT] PLOC receive execution failure report
+  //! P1: Command Id which leads the execution failure report
+  //! P2: The status field inserted by the MPSoC into the data field
   static const Event EXE_FAILURE = MAKE_EVENT(3, severity::LOW);
-  //! PLOC reply has invalid crc
+  //! [EXPORT] : [COMMENT] PLOC reply has invalid crc
-  static const Event CRC_FAILURE_EVENT = MAKE_EVENT(4, severity::LOW);
+  static const Event MPSOC_HANDLER_CRC_FAILURE = MAKE_EVENT(4, severity::LOW);
+  //! [EXPORT] : [COMMENT] Packet sequence count in received space packet does not match expected
+  //! count P1: Expected sequence count P2: Received sequence count
+  static const Event MPSOC_HANDLER_SEQ_CNT_MISMATCH = MAKE_EVENT(5, severity::LOW);
+
+  //! [EXPORT] : [COMMENT] Received command has file string with invalid length
+  static const ReturnValue_t NAME_TOO_LONG = MAKE_RETURN_CODE(0xD0);
 
   static const uint16_t APID_MASK = 0x7FF;
   static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
+  static const uint8_t STATUS_OFFSET = 10;
 
-  uint8_t commandBuffer[PLOC_MPSOC::MAX_COMMAND_SIZE];
+  MessageQueueIF* eventQueue = nullptr;
 
-  /**
+  SourceSequenceCounter sequenceCount;
-   * @brief   This object is incremented each time a packet is sent or received. By checking the
+
-   *          packet sequence count of a received packet, no packets can be lost without noticing
+  uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE];
-   *          it. Only the least significant 14 bits represent the packet sequence count in a
-   *          space packet. Thus the maximum value amounts to 16383 (0x3FFF).
-   * @note    Normally this should never happen because the PLOC replies are always sent in a
-   *          fixed order. However, the PLOC software checks this value and will return an ACK
-   *          failure report in case the sequence count is not incremented with each transferred
-   *          space packet.
-   */
-  uint16_t packetSequenceCount = 0x3FFF;
 
   /**
    * This variable is used to store the id of the next reply to receive. This is necessary
    * because the PLOC sends as reply to each command at least one acknowledgment and execution
    * report.
    */
-  DeviceCommandId_t nextReplyId = PLOC_MPSOC::NONE;
+  DeviceCommandId_t nextReplyId = mpsoc::NONE;
+
+  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;
+
+  class TmMemReadReport {
+   public:
+    static const uint8_t FIX_SIZE = 14;
+    size_t rememberRequestedSize = 0;
+  };
+
+  TmMemReadReport tmMemReadReport;
 
   /**
-   * @brief   This function fills the commandBuffer to initiate the write memory command.
+   * @brief   Handles events received from the PLOC MPSoC helper
-   *
-   * @param commandData   Pointer to action command data.
-   * @param commanDataLen Size of command data in bytes.
-   *
-   * @return RETURN_OK if successful, else RETURN_FAILURE.
    */
-  ReturnValue_t prepareTcMemWriteCommand(const uint8_t* commandData, size_t commandDataLen);
+  void handleEvent(EventMessage* eventMessage);
+
+  ReturnValue_t prepareTcMemWrite(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 prepareTcReplayStart(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t prepareTcReplayStop();
+  ReturnValue_t prepareTcDownlinkPwrOn(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t prepareTcDownlinkPwrOff();
+  ReturnValue_t prepareTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen);
 
   /**
-   * @brief   This function fills the commandBuffer to initiate the write reads command.
+   * @brief   Copies space packet into command buffer
-   *
-   * @param commandData   Pointer to action command data.
-   * @param commanDataLen Size of command data in bytes.
-   *
-   * @return RETURN_OK if successful, else RETURN_FAILURE.
    */
-  ReturnValue_t prepareTcMemReadCommand(const uint8_t* commandData, size_t commandDataLen);
+  void copyToCommandBuffer(mpsoc::TcBase* tc);
 
   /**
    * @brief   This function checks the crc of the received PLOC reply.
@@ -193,20 +207,11 @@ class PlocMPSoCHandler : public DeviceHandlerBase {
    */
   void disableExeReportReply();
 
-  /**
+  void printStatus(const uint8_t* data);
-   * @brief   This function checks and increments the packet sequence count of a received space
+
-   *          packet.
+  ReturnValue_t prepareTcModeReplay();
-   *
+
-   * @param data  Pointer to a space packet.
+  uint16_t getStatus(const uint8_t* data);
-   *
-   * @return RETURN_OK if successful
-   *
-   * @details There should be never a case in which a wrong packet sequence count is received
-   *          because the communication scheme between PLOC and OBC always follows a strict
-   *          procedure. Thus this function mainly serves for debugging purposes to detected an
-   *          invalid handling of the packet sequence count.
-   */
-  ReturnValue_t checkPacketSequenceCount(const uint8_t* data);
 };
 
-#endif /* MISSION_DEVICES_PLOCMPSOCHANDLER_H_ */
+#endif /* BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ */

linux/devices/ploc/PlocMPSoCHelper.cpp

@@ -0,0 +1,321 @@
+#include "PlocMPSoCHelper.h"
+
+#include <filesystem>
+#include <fstream>
+
+#include "OBSWConfig.h"
+#ifdef XIPHOS_Q7S
+#include "bsp_q7s/memory/FilesystemHelper.h"
+#endif
+
+#include "mission/utility/Timestamp.h"
+
+PlocMPSoCHelper::PlocMPSoCHelper(object_id_t objectId) : SystemObject(objectId) {}
+
+PlocMPSoCHelper::~PlocMPSoCHelper() {}
+
+ReturnValue_t PlocMPSoCHelper::initialize() {
+#ifdef XIPHOS_Q7S
+  sdcMan = SdCardManager::instance();
+  if (sdcMan == nullptr) {
+    sif::warning << "PlocMPSoCHelper::initialize: Invalid SD Card Manager" << std::endl;
+    return RETURN_FAILED;
+  }
+#endif
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHelper::performOperation(uint8_t operationCode) {
+  ReturnValue_t result = RETURN_OK;
+  semaphore.acquire();
+  while (true) {
+    switch (internalState) {
+      case InternalState::IDLE: {
+        semaphore.acquire();
+        break;
+      }
+      case InternalState::FLASH_WRITE: {
+        result = performFlashWrite();
+        if (result == RETURN_OK) {
+          triggerEvent(MPSOC_FLASH_WRITE_SUCCESSFUL);
+        } else {
+          triggerEvent(MPSOC_FLASH_WRITE_FAILED);
+        }
+        internalState = InternalState::IDLE;
+        break;
+      }
+      default:
+        sif::debug << "PlocMPSoCHelper::performOperation: Invalid state" << std::endl;
+        break;
+    }
+  }
+}
+
+ReturnValue_t PlocMPSoCHelper::setComIF(DeviceCommunicationIF* communicationInterface_) {
+  uartComIF = dynamic_cast<UartComIF*>(communicationInterface_);
+  if (uartComIF == nullptr) {
+    sif::warning << "PlocMPSoCHelper::initialize: Invalid uart com if" << std::endl;
+    return RETURN_FAILED;
+  }
+  return RETURN_OK;
+}
+
+void PlocMPSoCHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; }
+
+void PlocMPSoCHelper::setSequenceCount(SourceSequenceCounter* sequenceCount_) {
+  sequenceCount = sequenceCount_;
+}
+
+ReturnValue_t PlocMPSoCHelper::startFlashWrite(std::string obcFile, std::string mpsocFile) {
+  ReturnValue_t result = RETURN_OK;
+#ifdef XIPHOS_Q7S
+  result = FilesystemHelper::checkPath(obcFile);
+  if (result != RETURN_OK) {
+    return result;
+  }
+  result = FilesystemHelper::fileExists(mpsocFile);
+  if (result != RETURN_OK) {
+    return result;
+  }
+#endif
+#ifdef TE0720_1CFA
+  if (not std::filesystem::exists(obcFile)) {
+    sif::warning << "PlocMPSoCHelper::startFlashWrite: File " << obcFile << "does not exist"
+                 << std::endl;
+    return RETURN_FAILED;
+  }
+#endif
+
+  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;
+  result = uartComIF->flushUartRxBuffer(comCookie);
+  return result;
+}
+
+void PlocMPSoCHelper::stopProcess() { terminate = true; }
+
+ReturnValue_t PlocMPSoCHelper::performFlashWrite() {
+  ReturnValue_t result = RETURN_OK;
+  result = flashfopen();
+  if (result != RETURN_OK) {
+    return result;
+  }
+  uint8_t tempData[mpsoc::MAX_DATA_SIZE];
+  std::ifstream file(flashWrite.obcFile, std::ifstream::binary);
+  // Set position of next character to end of file input stream
+  file.seekg(0, file.end);
+  // tellg returns position of character in input stream
+  size_t remainingSize = file.tellg();
+  size_t dataLength = 0;
+  size_t bytesRead = 0;
+  while (remainingSize > 0) {
+    if (terminate) {
+      return RETURN_OK;
+    }
+    if (remainingSize > mpsoc::MAX_DATA_SIZE) {
+      dataLength = mpsoc::MAX_DATA_SIZE;
+    } 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 = handlePacketTransmission(tc);
+    if (result != RETURN_OK) {
+      return result;
+    }
+  }
+  result = flashfclose();
+  if (result != RETURN_OK) {
+    return result;
+  }
+  return result;
+}
+
+ReturnValue_t PlocMPSoCHelper::flashfopen() {
+  ReturnValue_t result = RETURN_OK;
+  (*sequenceCount)++;
+  mpsoc::FlashFopen flashFopen(*sequenceCount);
+  result = flashFopen.createPacket(flashWrite.mpsocFile, mpsoc::FlashFopen::APPEND);
+  if (result != RETURN_OK) {
+    return result;
+  }
+  result = handlePacketTransmission(flashFopen);
+  if (result != RETURN_OK) {
+    return result;
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHelper::flashfclose() {
+  ReturnValue_t result = RETURN_OK;
+  (*sequenceCount)++;
+  mpsoc::FlashFclose flashFclose(*sequenceCount);
+  result = flashFclose.createPacket(flashWrite.mpsocFile);
+  if (result != RETURN_OK) {
+    return result;
+  }
+  result = handlePacketTransmission(flashFclose);
+  if (result != RETURN_OK) {
+    return result;
+  }
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHelper::handlePacketTransmission(mpsoc::TcBase& tc) {
+  ReturnValue_t result = RETURN_OK;
+  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));
+    return result;
+  }
+  return result;
+}
+
+ReturnValue_t PlocMPSoCHelper::handleAck() {
+  ReturnValue_t result = RETURN_OK;
+  mpsoc::TmPacket tmPacket;
+  result = handleTmReception(&tmPacket, mpsoc::SIZE_ACK_REPORT);
+  if (result != RETURN_OK) {
+    return result;
+  }
+  uint16_t apid = tmPacket.getAPID();
+  if (apid != mpsoc::apid::ACK_SUCCESS) {
+    handleAckApidFailure(apid);
+    return RETURN_FAILED;
+  }
+  return RETURN_OK;
+}
+
+void PlocMPSoCHelper::handleAckApidFailure(uint16_t apid) {
+  if (apid == mpsoc::apid::ACK_FAILURE) {
+    triggerEvent(ACK_FAILURE_REPORT, static_cast<uint32_t>(internalState));
+    sif::warning << "PlocMPSoCHelper::handleAckApidFailure: Received acknowledgement failure "
+                 << "report" << std::endl;
+  } else {
+    triggerEvent(ACK_INVALID_APID, apid, static_cast<uint32_t>(internalState));
+    sif::warning << "PlocMPSoCHelper::handleAckApidFailure: Expected acknowledgement report "
+                 << "but received space packet with apid " << std::hex << apid << std::endl;
+  }
+}
+
+ReturnValue_t PlocMPSoCHelper::handleExe() {
+  ReturnValue_t result = RETURN_OK;
+  mpsoc::TmPacket tmPacket;
+  result = handleTmReception(&tmPacket, mpsoc::SIZE_EXE_REPORT);
+  if (result != RETURN_OK) {
+    return result;
+  }
+  uint16_t apid = tmPacket.getAPID();
+  if (apid != mpsoc::apid::EXE_SUCCESS) {
+    handleExeApidFailure(apid);
+    return RETURN_FAILED;
+  }
+  return RETURN_OK;
+}
+
+void PlocMPSoCHelper::handleExeApidFailure(uint16_t apid) {
+  if (apid == mpsoc::apid::EXE_FAILURE) {
+    triggerEvent(EXE_FAILURE_REPORT, static_cast<uint32_t>(internalState));
+    sif::warning << "PlocMPSoCHelper::handleExeApidFailure: Received execution failure "
+                 << "report" << std::endl;
+  } else {
+    triggerEvent(EXE_INVALID_APID, apid, static_cast<uint32_t>(internalState));
+    sif::warning << "PlocMPSoCHelper::handleExeApidFailure: Expected execution report "
+                 << "but received space packet with apid " << std::hex << apid << std::endl;
+  }
+}
+
+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, &currentBytes, remainingBytes);
+    if (result != RETURN_OK) {
+      return result;
+    }
+    readBytes += currentBytes;
+    remainingBytes = remainingBytes - currentBytes;
+    if (remainingBytes == 0) {
+      break;
+    }
+  }
+  if (remainingBytes != 0) {
+    sif::warning << "PlocMPSoCHelper::handleTmReception: Failed to receive reply" << std::endl;
+    triggerEvent(MISSING_EXE, remainingBytes, static_cast<uint32_t>(internalState));
+    return RETURN_FAILED;
+  }
+  result = tmPacket->checkCrc();
+  if (result != RETURN_OK) {
+    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;
+}
+
+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;
+    triggerEvent(MPSOC_HELPER_REQUESTING_REPLY_FAILED, result,
+                 static_cast<uint32_t>(static_cast<uint32_t>(internalState)));
+    return RETURN_FAILED;
+  }
+  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

@@ -0,0 +1,153 @@
+#ifndef BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_
+#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/tasks/ExecutableObjectIF.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"
+#endif
+
+/**
+ * @brief   Helper class for MPSoC of PLOC intended to accelerate large data transfers between
+ *          MPSoC and OBC.
+ * @author  J. Meier
+ */
+class PlocMPSoCHelper : public SystemObject, public ExecutableObjectIF, public HasReturnvaluesIF {
+ 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
+  //! 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
+  //! P2: Internal state of MPSoC helper
+  static const Event MPSOC_HELPER_REQUESTING_REPLY_FAILED = MAKE_EVENT(3, severity::LOW);
+  //! [EXPORT] : [COMMENT] Reading receive message of communication interface failed
+  //! P1: Return value returned by the communication interface readingReceivedMessage function
+  //! P2: Internal state of MPSoC helper
+  static const Event MPSOC_HELPER_READING_REPLY_FAILED = MAKE_EVENT(4, severity::LOW);
+  //! [EXPORT] : [COMMENT] Did not receive acknowledgement report
+  //! P1: Number of bytes missing
+  //! 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
+  //! 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
+  static const Event ACK_FAILURE_REPORT = MAKE_EVENT(7, severity::LOW);
+  //! [EXPORT] : [COMMENT] Received execution failure report
+  //! 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
+  //! 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
+  //! 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
+  //! P2: Received sequence count
+  static const Event MPSOC_HELPER_SEQ_CNT_MISMATCH = MAKE_EVENT(11, severity::LOW);
+
+  PlocMPSoCHelper(object_id_t objectId);
+  virtual ~PlocMPSoCHelper();
+
+  ReturnValue_t initialize() override;
+  ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+  ReturnValue_t setComIF(DeviceCommunicationIF* communicationInterface_);
+  void setComCookie(CookieIF* comCookie_);
+
+  /**
+   * @brief   Starts flash write sequence
+   *
+   * @param obcFile   File where to read from the data
+   * @param mpsocFile The file of the MPSoC where should be written to
+   *
+   * @return  RETURN_OK if successful, otherwise error return value
+   */
+  ReturnValue_t startFlashWrite(std::string obcFile, std::string mpsocFile);
+
+  /**
+   * @brief   Can be used to interrupt a running data transfer.
+   */
+  void stopProcess();
+
+  /**
+   * @brief   Sets the sequence count object responsible for the sequence count handling
+   */
+  void setSequenceCount(SourceSequenceCounter* sequenceCount_);
+
+ private:
+  static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MPSOC_HELPER;
+
+  //! [EXPORT] : [COMMENT] File 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 = 10000;
+
+  struct FlashWrite {
+    std::string obcFile;
+    std::string mpsocFile;
+  };
+
+  struct FlashWrite flashWrite;
+
+  enum class InternalState { IDLE, FLASH_WRITE, FLASH_READ };
+
+  InternalState internalState = InternalState::IDLE;
+
+  BinarySemaphore semaphore;
+#ifdef XIPHOS_Q7S
+  SdCardManager* sdcMan = nullptr;
+#endif
+  uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE];
+
+  bool terminate = false;
+
+  /**
+   * Communication interface of MPSoC responsible for low level access. Must be set by the
+   * MPSoC Handler.
+   */
+  UartComIF* uartComIF = nullptr;
+  // Communication cookie. Must be set by the MPSoC Handler
+  CookieIF* comCookie = nullptr;
+  // Sequence count, must be set by Ploc MPSoC Handler
+  SourceSequenceCounter* sequenceCount;
+
+  ReturnValue_t resetHelper();
+  ReturnValue_t performFlashWrite();
+  ReturnValue_t flashfopen();
+  ReturnValue_t flashfclose();
+  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();
+  void handleAckApidFailure(uint16_t apid);
+  void handleExeApidFailure(uint16_t apid);
+  ReturnValue_t handleTmReception(mpsoc::TmPacket* tmPacket, size_t remainingBytes);
+};
+
+#endif /* BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_ */

linux/devices/ploc/PlocMemoryDumper.h

@@ -1,8 +1,8 @@
 #ifndef MISSION_DEVICES_PLOCMEMORYDUMPER_H_
 #define MISSION_DEVICES_PLOCMEMORYDUMPER_H_
 
-#include <bsp_q7s/devices/devicedefinitions/PlocMemDumpDefinitions.h>
+#include <linux/devices/devicedefinitions/PlocMemDumpDefinitions.h>
-#include <bsp_q7s/devices/devicedefinitions/PlocSupervisorDefinitions.h>
+#include <linux/devices/devicedefinitions/PlocSupervisorDefinitions.h>
 
 #include "OBSWConfig.h"
 #include "bsp_q7s/memory/SdCardManager.h"

linux/devices/ploc/PlocSupervisorHandler.cpp

@@ -12,8 +12,9 @@
 #include "OBSWConfig.h"
 
 PlocSupervisorHandler::PlocSupervisorHandler(object_id_t objectId, object_id_t uartComIFid,
-                                             CookieIF* comCookie)
+                                             CookieIF* comCookie, Gpio uartIsolatorSwitch)
     : DeviceHandlerBase(objectId, uartComIFid, comCookie),
+      uartIsolatorSwitch(uartIsolatorSwitch),
       hkset(this),
       bootStatusReport(this),
       latchupStatusReport(this) {
@@ -33,25 +34,23 @@ ReturnValue_t PlocSupervisorHandler::initialize() {
   uartComIf = dynamic_cast<UartComIF*>(communicationInterface);
   if (uartComIf == nullptr) {
     sif::warning << "PlocSupervisorHandler::initialize: Invalid uart com if" << std::endl;
-    return INVALID_UART_COM_IF;
+    return ObjectManagerIF::CHILD_INIT_FAILED;
   }
-
+#ifdef TE0720_1CFA
-#if BOARD_TE0720 == 0
   sdcMan = SdCardManager::instance();
 #endif /* BOARD_TE0720 == 0 */
-
   return result;
 }
 
 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() { setMode(_MODE_POWER_DOWN); }
+void PlocSupervisorHandler::doShutDown() {
+  setMode(_MODE_POWER_DOWN);
+  uartIsolatorSwitch.pullLow();
+}
 
 ReturnValue_t PlocSupervisorHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
   return NOTHING_TO_SEND;
@@ -380,6 +379,13 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t r
   return result;
 }
 
+ReturnValue_t PlocSupervisorHandler::getSwitches(const uint8_t** switches,
+                                                 uint8_t* numberOfSwitches) {
+  *numberOfSwitches = 1;
+  *switches = &powerSwitch;
+  return RETURN_OK;
+}
+
 ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
                                                           const uint8_t* packet) {
   ReturnValue_t result = RETURN_OK;
@@ -594,13 +600,10 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite
 
 ReturnValue_t PlocSupervisorHandler::verifyPacket(const uint8_t* start, size_t foundLen) {
   uint16_t receivedCrc = *(start + foundLen - 2) << 8 | *(start + foundLen - 1);
-
   uint16_t recalculatedCrc = CRC::crc16ccitt(start, foundLen - 2);
-
   if (receivedCrc != recalculatedCrc) {
     return CRC_FAILURE;
   }
-
   return RETURN_OK;
 }
 
@@ -1476,7 +1479,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");

linux/devices/ploc/PlocSupervisorHandler.h

@@ -1,12 +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 "OBSWConfig.h"
-#include "devicedefinitions/PlocSupervisorDefinitions.h"
+#include "bsp_q7s/memory/SdCardManager.h"
+#include "devices/powerSwitcherList.h"
+#include "fsfw/devicehandlers/DeviceHandlerBase.h"
+#include "fsfw_hal/linux/gpio/Gpio.h"
+#include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
+#include "fsfw_hal/linux/uart/UartComIF.h"
+#include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"
 
 /**
  * @brief	This is the device handler for the supervisor of the PLOC which is programmed by
@@ -22,7 +24,8 @@
  */
 class PlocSupervisorHandler : public DeviceHandlerBase {
  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;
@@ -60,35 +63,33 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   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] Invalid communication interface specified
-  static const ReturnValue_t INVALID_UART_COM_IF = MAKE_RETURN_CODE(0xA5);
   //! [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(0xA6);
+  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.
-  static const ReturnValue_t INVALID_WATCHDOG_TIMEOUT = MAKE_RETURN_CODE(0xA7);
+  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(0xA8);
+  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.
-  static const ReturnValue_t SWEEP_PERIOD_TOO_SMALL = MAKE_RETURN_CODE(0xA9);
+  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.
-  static const ReturnValue_t INVALID_TEST_PARAM = MAKE_RETURN_CODE(0xAA);
+  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(0xAB);
+  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)
-  static const ReturnValue_t INVALID_MRAM_ADDRESSES = MAKE_RETURN_CODE(0xAC);
+  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.
-  static const ReturnValue_t NO_MRAM_PACKET = MAKE_RETURN_CODE(0xAD);
+  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(0xAE);
+  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.
-  static const ReturnValue_t MRAM_FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xAF);
+  static const ReturnValue_t MRAM_FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xAE);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_SUPERVISOR_HANDLER;
 
@@ -114,11 +115,15 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   DeviceCommandId_t nextReplyId = PLOC_SPV::NONE;
 
   UartComIF* uartComIf = nullptr;
+  LinuxLibgpioIF* gpioComIF = nullptr;
+  Gpio uartIsolatorSwitch;
 
   PLOC_SPV::HkSet hkset;
   PLOC_SPV::BootStatusReport bootStatusReport;
   PLOC_SPV::LatchupStatusReport latchupStatusReport;
 
+  const power::Switch_t powerSwitch = pcduSwitches::PDU1_CH6_PLOC_12V;
+
   /** Number of expected replies following the MRAM dump command */
   uint32_t expectedMramDumpPackets = 0;
   uint32_t receivedMramDumpPackets = 0;
@@ -130,7 +135,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   /** 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 */
 
@@ -141,6 +146,8 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   /** Setting this variable to true will enable direct downlink of MRAM packets */
   bool downlinkMramDump = false;
 
+  ReturnValue_t getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches);
+
   /**
    * @brief   This function checks the crc of the received PLOC reply.
    *

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,9 +1,10 @@
 #ifndef MISSION_DEVICES_PLOCUPDATER_H_
 #define MISSION_DEVICES_PLOCUPDATER_H_
 
+#include <linux/devices/devicedefinitions/PlocSupervisorDefinitions.h>
+
 #include "OBSWConfig.h"
 #include "bsp_q7s/memory/SdCardManager.h"
-#include "devicedefinitions/PlocSupervisorDefinitions.h"
 #include "eive/definitions.h"
 #include "fsfw/action/ActionHelper.h"
 #include "fsfw/action/CommandActionHelper.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

@@ -10,6 +10,7 @@
 #cmakedefine XIPHOS_Q7S
 #cmakedefine BEAGLEBONEBLACK
 #cmakedefine EGSE
+#cmakedefine TE0720_1CFA
 
 #include "commonConfig.h"
 #include "OBSWVersion.h"
@@ -17,9 +18,7 @@
 /* These defines should be disabled for mission code but are useful for
 debugging. */
 #define OBSW_VERBOSE_LEVEL                          1
-
+                             
-//! Board defines
-#define BOARD_TE0720                                0                                   
 #define Q7S_EM                                      0
 
 /*******************************************************************/
@@ -30,6 +29,8 @@ debugging. */
 //! All of this should be enabled for mission code!
 #if defined XIPHOS_Q7S
 
+#define Q7S_EM                                      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
@@ -64,6 +65,37 @@ debugging. */
 #define OBSW_INITIALIZE_SWITCHES                    0
 #define OBSW_ENABLE_PERIODIC_HK                     0
 
+#ifdef TE0720_1CFA
+
+#define OBSW_USE_CCSDS_IP_CORE                      0
+// 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
+#define OBSW_TC_FROM_PDEC                           0
+#define OBSW_ENABLE_TIMERS                          1
+#define OBSW_ADD_MGT                                0
+#define OBSW_ADD_BPX_BATTERY_HANDLER                0
+#define OBSW_ADD_STAR_TRACKER                       0
+#define OBSW_ADD_PLOC_SUPERVISOR                    0
+#define OBSW_ADD_PLOC_MPSOC                         1
+#define OBSW_ADD_SUN_SENSORS                        0
+#define OBSW_ADD_ACS_BOARD                          1
+#define OBSW_ADD_ACS_HANDLERS                       0
+#define OBSW_ADD_RW                                 0
+#define OBSW_ADD_RTD_DEVICES                        0
+#define OBSW_ADD_TMP_DEVICES                        0
+#define OBSW_ADD_RAD_SENSORS                        0
+#define OBSW_ADD_PL_PCDU                            0
+#define OBSW_ADD_SYRLINKS                           0
+#define OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT       0
+#define OBSW_SYRLINKS_SIMULATED										  1
+#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
+
 /*******************************************************************/
 /** All of the following flags should be disabled for mission code */
 /*******************************************************************/
@@ -113,10 +145,21 @@ 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
-#define OBSW_DEBUG_STARTRACKER                      @OBSW_DEBUG_STARTRACKER@
+
+#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
+#define OBSW_DEBUG_STARTRACKER                      0
+#endif
 
 #ifdef RASPBERRY_PI
 
@@ -141,6 +184,11 @@ debugging. */
 
 #endif // RASPBERRY_PI
 
+#define TCP_SERVER_WIRETAPPING                      0
+
+/*******************************************************************/
+/** CMake Defines                                                  */
+/*******************************************************************/
 #cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER
 
 #ifdef RASPBERRY_PI
@@ -155,11 +203,6 @@ debugging. */
 #include "events/subsystemIdRanges.h"
 #include "returnvalues/classIds.h"
 
-namespace config {
-#endif
-
-#ifdef __cplusplus
-}
 #endif
 
 #endif /* FSFWCONFIG_OBSWCONFIG_H_ */

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 168 translations.
+ * @brief    Auto-generated event translation file. Contains 181 translations.
  * @details
- * Generated on: 2022-03-22 20:43:04
+ * Generated on: 2022-03-28 12:48:26
  */
 #include "translateEvents.h"
 
@@ -100,7 +100,8 @@ const char *DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_ON_FAI
 const char *MEMORY_READ_RPT_CRC_FAILURE_STRING = "MEMORY_READ_RPT_CRC_FAILURE";
 const char *ACK_FAILURE_STRING = "ACK_FAILURE";
 const char *EXE_FAILURE_STRING = "EXE_FAILURE";
-const char *CRC_FAILURE_EVENT_STRING = "CRC_FAILURE_EVENT";
+const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE";
+const char *MPSOC_HANDLER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQ_CNT_MISMATCH";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@@ -148,6 +149,18 @@ const char *POSITION_MISMATCH_STRING = "POSITION_MISMATCH";
 const char *STR_HELPER_FILE_NOT_EXISTS_STRING = "STR_HELPER_FILE_NOT_EXISTS";
 const char *STR_HELPER_SENDING_PACKET_FAILED_STRING = "STR_HELPER_SENDING_PACKET_FAILED";
 const char *STR_HELPER_REQUESTING_MSG_FAILED_STRING = "STR_HELPER_REQUESTING_MSG_FAILED";
+const char *MPSOC_FLASH_WRITE_FAILED_STRING = "MPSOC_FLASH_WRITE_FAILED";
+const char *MPSOC_FLASH_WRITE_SUCCESSFUL_STRING = "MPSOC_FLASH_WRITE_SUCCESSFUL";
+const char *SENDING_COMMAND_FAILED_STRING = "SENDING_COMMAND_FAILED";
+const char *MPSOC_HELPER_REQUESTING_REPLY_FAILED_STRING = "MPSOC_HELPER_REQUESTING_REPLY_FAILED";
+const char *MPSOC_HELPER_READING_REPLY_FAILED_STRING = "MPSOC_HELPER_READING_REPLY_FAILED";
+const char *MISSING_ACK_STRING = "MISSING_ACK";
+const char *MISSING_EXE_STRING = "MISSING_EXE";
+const char *ACK_FAILURE_REPORT_STRING = "ACK_FAILURE_REPORT";
+const char *EXE_FAILURE_REPORT_STRING = "EXE_FAILURE_REPORT";
+const char *ACK_INVALID_APID_STRING = "ACK_INVALID_APID";
+const char *EXE_INVALID_APID_STRING = "EXE_INVALID_APID";
+const char *MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING = "MPSOC_HELPER_SEQ_CNT_MISMATCH";
 const char *TRANSITION_BACK_TO_OFF_STRING = "TRANSITION_BACK_TO_OFF";
 const char *NEG_V_OUT_OF_BOUNDS_STRING = "NEG_V_OUT_OF_BOUNDS";
 const char *U_DRO_OUT_OF_BOUNDS_STRING = "U_DRO_OUT_OF_BOUNDS";
@@ -363,7 +376,9 @@ const char *translateEvents(Event event) {
     case (11103):
       return EXE_FAILURE_STRING;
     case (11104):
-      return CRC_FAILURE_EVENT_STRING;
+      return MPSOC_HANDLER_CRC_FAILURE_STRING;
+    case (11105):
+      return MPSOC_HANDLER_SEQ_CNT_MISMATCH_STRING;
     case (11201):
       return SELF_TEST_I2C_FAILURE_STRING;
     case (11202):
@@ -459,38 +474,62 @@ const char *translateEvents(Event event) {
     case (12016):
       return STR_HELPER_REQUESTING_MSG_FAILED_STRING;
     case (12100):
-      return TRANSITION_BACK_TO_OFF_STRING;
+      return MPSOC_FLASH_WRITE_FAILED_STRING;
     case (12101):
-      return NEG_V_OUT_OF_BOUNDS_STRING;
+      return MPSOC_FLASH_WRITE_SUCCESSFUL_STRING;
     case (12102):
-      return U_DRO_OUT_OF_BOUNDS_STRING;
+      return SENDING_COMMAND_FAILED_STRING;
     case (12103):
-      return I_DRO_OUT_OF_BOUNDS_STRING;
+      return MPSOC_HELPER_REQUESTING_REPLY_FAILED_STRING;
     case (12104):
-      return U_X8_OUT_OF_BOUNDS_STRING;
+      return MPSOC_HELPER_READING_REPLY_FAILED_STRING;
     case (12105):
-      return I_X8_OUT_OF_BOUNDS_STRING;
+      return MISSING_ACK_STRING;
     case (12106):
-      return U_TX_OUT_OF_BOUNDS_STRING;
+      return MISSING_EXE_STRING;
     case (12107):
-      return I_TX_OUT_OF_BOUNDS_STRING;
+      return ACK_FAILURE_REPORT_STRING;
     case (12108):
-      return U_MPA_OUT_OF_BOUNDS_STRING;
+      return EXE_FAILURE_REPORT_STRING;
     case (12109):
-      return I_MPA_OUT_OF_BOUNDS_STRING;
+      return ACK_INVALID_APID_STRING;
     case (12110):
-      return U_HPA_OUT_OF_BOUNDS_STRING;
+      return EXE_INVALID_APID_STRING;
     case (12111):
-      return I_HPA_OUT_OF_BOUNDS_STRING;
+      return MPSOC_HELPER_SEQ_CNT_MISMATCH_STRING;
     case (12200):
-      return TRANSITION_OTHER_SIDE_FAILED_STRING;
+      return TRANSITION_BACK_TO_OFF_STRING;
     case (12201):
-      return NOT_ENOUGH_DEVICES_DUAL_MODE_STRING;
+      return NEG_V_OUT_OF_BOUNDS_STRING;
     case (12202):
-      return POWER_STATE_MACHINE_TIMEOUT_STRING;
+      return U_DRO_OUT_OF_BOUNDS_STRING;
     case (12203):
+      return I_DRO_OUT_OF_BOUNDS_STRING;
+    case (12204):
+      return U_X8_OUT_OF_BOUNDS_STRING;
+    case (12205):
+      return I_X8_OUT_OF_BOUNDS_STRING;
+    case (12206):
+      return U_TX_OUT_OF_BOUNDS_STRING;
+    case (12207):
+      return I_TX_OUT_OF_BOUNDS_STRING;
+    case (12208):
+      return U_MPA_OUT_OF_BOUNDS_STRING;
+    case (12209):
+      return I_MPA_OUT_OF_BOUNDS_STRING;
+    case (12210):
+      return U_HPA_OUT_OF_BOUNDS_STRING;
+    case (12211):
+      return I_HPA_OUT_OF_BOUNDS_STRING;
+    case (12300):
+      return TRANSITION_OTHER_SIDE_FAILED_STRING;
+    case (12301):
+      return NOT_ENOUGH_DEVICES_DUAL_MODE_STRING;
+    case (12302):
+      return POWER_STATE_MACHINE_TIMEOUT_STRING;
+    case (12303):
       return SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING;
-    case (12400):
+    case (12500):
       return CHILDREN_LOST_MODE_STRING;
     case (13600):
       return ALLOC_FAILURE_STRING;

linux/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 115 translations.
+ * Contains 117 translations.
- * Generated on: 2022-03-22 20:43:04
+ * Generated on: 2022-03-28 12:48:33
  */
 #include "translateObjects.h"
 
@@ -48,8 +48,10 @@ const char *RAD_SENSOR_STRING = "RAD_SENSOR";
 const char *PLOC_UPDATER_STRING = "PLOC_UPDATER";
 const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER";
 const char *STR_HELPER_STRING = "STR_HELPER";
+const char *PLOC_MPSOC_HELPER_STRING = "PLOC_MPSOC_HELPER";
 const char *PLOC_MPSOC_HANDLER_STRING = "PLOC_MPSOC_HANDLER";
 const char *PLOC_SUPERVISOR_HANDLER_STRING = "PLOC_SUPERVISOR_HANDLER";
+const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER";
 const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
 const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
 const char *TMP1075_HANDLER_1_STRING = "TMP1075_HANDLER_1";
@@ -208,10 +210,14 @@ const char *translateObject(object_id_t object) {
       return PLOC_MEMORY_DUMPER_STRING;
     case 0x44330002:
       return STR_HELPER_STRING;
+    case 0x44330003:
+      return PLOC_MPSOC_HELPER_STRING;
     case 0x44330015:
       return PLOC_MPSOC_HANDLER_STRING;
     case 0x44330016:
       return PLOC_SUPERVISOR_HANDLER_STRING;
+    case 0x44330017:
+      return PLOC_SUPERVISOR_HELPER_STRING;
     case 0x444100A2:
       return SOLAR_ARRAY_DEPL_HANDLER_STRING;
     case 0x444100A4:

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -517,6 +517,7 @@ ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) {
 
 ReturnValue_t pst::pstGompaceCan(FixedTimeslotTaskIF *thisSequence) {
   uint32_t length = thisSequence->getPeriodMs();
+#ifndef TE0720_1CFA
 #if Q7S_EM != 1
   // PCDU handlers receives two messages and both must be handled
   thisSequence->addSlot(objects::PCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
@@ -551,6 +552,7 @@ ReturnValue_t pst::pstGompaceCan(FixedTimeslotTaskIF *thisSequence) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
 #endif /* Q7S_EM == 0 */
+#endif
   static_cast<void>(length);
   return HasReturnvaluesIF::RETURN_OK;
 }
@@ -590,69 +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 TEST_PLOC_MPSOC_HANDLER == 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;

mission/core/GenericFactory.cpp

@@ -111,6 +111,9 @@ void ObjectFactory::produceGenericObjects() {
   tcpServer->setSpacePacketParsingOptions({common::PUS_PACKET_ID});
   sif::info << "Created TCP server for TMTC commanding with listener port "
             << tcpServer->getTcpPort() << std::endl;
+#if TCP_SERVER_WIRETAPPING == 1
+  tcpServer->enableWiretapping(true);
+#endif /* TCP_SERVER_WIRETAPPING == 1 */
 #endif /* OBSW_USE_TMTC_TCP_BRIDGE == 0 */
   tmtcBridge->setMaxNumberOfPacketsStored(70);
 #endif /* OBSW_ADD_TCPIP_BRIDGE == 1 */

mission/devices/CMakeLists.txt

@@ -11,7 +11,6 @@ target_sources(${LIB_EIVE_MISSION} PRIVATE
     Max31865PT1000Handler.cpp
     IMTQHandler.cpp
     HeaterHandler.cpp
-    PlocMPSoCHandler.cpp
     RadiationSensorHandler.cpp
     GyroADIS1650XHandler.cpp
     RwHandler.cpp

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/devices/PayloadPcduHandler.cpp

@@ -525,6 +525,8 @@ void PayloadPcduHandler::checkAdcValues() {
     }
     params.getValue(PARAM_KEY_MAP[HPA_I_UPPER_BOUND], upperBound);
     if (not checkCurrent(adcSet.processed[I_HPA], upperBound, I_HPA_OUT_OF_BOUNDS)) {
+      sif::warning << "PayloadPcduHandler::checkCurrent: I HPA exceeded limit: Measured "
+                   << adcSet.processed[I_HPA] << " mA" << std::endl;
       return;
     }
   }

mission/devices/PlocMPSoCHandler.cpp

@@ -1,473 +0,0 @@
-#include "PlocMPSoCHandler.h"
-
-#include <fsfw/datapool/PoolReadGuard.h>
-#include <fsfw/globalfunctions/CRC.h>
-
-#include "OBSWConfig.h"
-
-PlocMPSoCHandler::PlocMPSoCHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie)
-    : DeviceHandlerBase(objectId, comIF, comCookie) {
-  if (comCookie == NULL) {
-    sif::error << "PlocMPSoCHandler: Invalid com cookie" << std::endl;
-  }
-}
-
-PlocMPSoCHandler::~PlocMPSoCHandler() {}
-
-void PlocMPSoCHandler::doStartUp() {
-  if (mode == _MODE_START_UP) {
-    setMode(MODE_ON);
-  }
-}
-
-void PlocMPSoCHandler::doShutDown() { setMode(_MODE_POWER_DOWN); }
-
-ReturnValue_t PlocMPSoCHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
-  return RETURN_OK;
-}
-
-ReturnValue_t PlocMPSoCHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t PlocMPSoCHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                        const uint8_t* commandData,
-                                                        size_t commandDataLen) {
-  switch (deviceCommand) {
-    case (PLOC_MPSOC::TC_MEM_WRITE): {
-      return prepareTcMemWriteCommand(commandData, commandDataLen);
-    }
-    case (PLOC_MPSOC::TC_MEM_READ): {
-      return prepareTcMemReadCommand(commandData, commandDataLen);
-    }
-    default:
-      sif::debug << "PlocMPSoCHandler::buildCommandFromCommand: Command not implemented"
-                 << std::endl;
-      return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
-  }
-  return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-void PlocMPSoCHandler::fillCommandAndReplyMap() {
-  this->insertInCommandMap(PLOC_MPSOC::TC_MEM_WRITE);
-  this->insertInCommandMap(PLOC_MPSOC::TC_MEM_READ);
-  this->insertInReplyMap(PLOC_MPSOC::ACK_REPORT, 1, nullptr, PLOC_MPSOC::SIZE_ACK_REPORT);
-  this->insertInReplyMap(PLOC_MPSOC::EXE_REPORT, 3, nullptr, PLOC_MPSOC::SIZE_EXE_REPORT);
-  this->insertInReplyMap(PLOC_MPSOC::TM_MEMORY_READ_REPORT, 2, nullptr,
-                         PLOC_MPSOC::SIZE_TM_MEM_READ_REPORT);
-}
-
-ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remainingSize,
-                                             DeviceCommandId_t* foundId, size_t* foundLen) {
-  ReturnValue_t result = RETURN_OK;
-
-  uint16_t apid = (*(start) << 8 | *(start + 1)) & APID_MASK;
-
-  switch (apid) {
-    case (PLOC_MPSOC::APID_ACK_SUCCESS):
-      *foundLen = PLOC_MPSOC::SIZE_ACK_REPORT;
-      *foundId = PLOC_MPSOC::ACK_REPORT;
-      break;
-    case (PLOC_MPSOC::APID_ACK_FAILURE):
-      *foundLen = PLOC_MPSOC::SIZE_ACK_REPORT;
-      *foundId = PLOC_MPSOC::ACK_REPORT;
-      break;
-    case (PLOC_MPSOC::APID_TM_MEMORY_READ_REPORT):
-      *foundLen = PLOC_MPSOC::SIZE_TM_MEM_READ_REPORT;
-      *foundId = PLOC_MPSOC::TM_MEMORY_READ_REPORT;
-      break;
-    case (PLOC_MPSOC::APID_EXE_SUCCESS):
-      *foundLen = PLOC_MPSOC::SIZE_EXE_REPORT;
-      *foundId = PLOC_MPSOC::EXE_REPORT;
-      break;
-    case (PLOC_MPSOC::APID_EXE_FAILURE):
-      *foundLen = PLOC_MPSOC::SIZE_EXE_REPORT;
-      *foundId = PLOC_MPSOC::EXE_REPORT;
-      break;
-    default: {
-      sif::debug << "PlocMPSoCHandler::scanForReply: Reply has invalid apid" << std::endl;
-      *foundLen = remainingSize;
-      return INVALID_APID;
-    }
-  }
-
-  /**
-   * This should normally never fail. However, this function is also responsible for incrementing
-   * the packet sequence count why it is called here.
-   */
-  result = checkPacketSequenceCount(start);
-
-  return result;
-}
-
-ReturnValue_t PlocMPSoCHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
-  ReturnValue_t result = RETURN_OK;
-
-  switch (id) {
-    case PLOC_MPSOC::ACK_REPORT: {
-      result = handleAckReport(packet);
-      break;
-    }
-    case (PLOC_MPSOC::TM_MEMORY_READ_REPORT): {
-      result = handleMemoryReadReport(packet);
-      break;
-    }
-    case (PLOC_MPSOC::EXE_REPORT): {
-      result = handleExecutionReport(packet);
-      break;
-    }
-    default: {
-      sif::debug << "PlocMPSoCHandler::interpretDeviceReply: Unknown device reply id" << std::endl;
-      return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
-    }
-  }
-
-  return result;
-}
-
-void PlocMPSoCHandler::setNormalDatapoolEntriesInvalid() {}
-
-uint32_t PlocMPSoCHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
-
-ReturnValue_t PlocMPSoCHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
-                                                        LocalDataPoolManager& poolManager) {
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-void PlocMPSoCHandler::setModeNormal() { mode = MODE_NORMAL; }
-
-ReturnValue_t PlocMPSoCHandler::prepareTcMemWriteCommand(const uint8_t* commandData,
-                                                         size_t commandDataLen) {
-  const uint32_t memoryAddress = *(commandData) << 24 | *(commandData + 1) << 16 |
-                                 *(commandData + 2) << 8 | *(commandData + 3);
-  const uint32_t memoryData = *(commandData + 4) << 24 | *(commandData + 5) << 16 |
-                              *(commandData + 6) << 8 | *(commandData + 7);
-  packetSequenceCount = (packetSequenceCount + 1) & PACKET_SEQUENCE_COUNT_MASK;
-  PLOC_MPSOC::TcMemWrite tcMemWrite(memoryAddress, memoryData, packetSequenceCount);
-  if (tcMemWrite.getFullSize() > PLOC_MPSOC::MAX_COMMAND_SIZE) {
-    sif::debug << "PlocMPSoCHandler::prepareTcMemWriteCommand: Command too big" << std::endl;
-    return RETURN_FAILED;
-  }
-  memcpy(commandBuffer, tcMemWrite.getWholeData(), tcMemWrite.getFullSize());
-  rawPacket = commandBuffer;
-  rawPacketLen = tcMemWrite.getFullSize();
-  nextReplyId = PLOC_MPSOC::ACK_REPORT;
-  return RETURN_OK;
-}
-
-ReturnValue_t PlocMPSoCHandler::prepareTcMemReadCommand(const uint8_t* commandData,
-                                                        size_t commandDataLen) {
-  const uint32_t memoryAddress = *(commandData) << 24 | *(commandData + 1) << 16 |
-                                 *(commandData + 2) << 8 | *(commandData + 3);
-  packetSequenceCount = (packetSequenceCount + 1) & PACKET_SEQUENCE_COUNT_MASK;
-  PLOC_MPSOC::TcMemRead tcMemRead(memoryAddress, packetSequenceCount);
-  if (tcMemRead.getFullSize() > PLOC_MPSOC::MAX_COMMAND_SIZE) {
-    sif::debug << "PlocMPSoCHandler::prepareTcMemReadCommand: Command too big" << std::endl;
-    return RETURN_FAILED;
-  }
-  memcpy(commandBuffer, tcMemRead.getWholeData(), tcMemRead.getFullSize());
-  rawPacket = commandBuffer;
-  rawPacketLen = tcMemRead.getFullSize();
-  nextReplyId = PLOC_MPSOC::ACK_REPORT;
-
-  return RETURN_OK;
-}
-
-ReturnValue_t PlocMPSoCHandler::verifyPacket(const uint8_t* start, size_t foundLen) {
-  uint16_t receivedCrc = *(start + foundLen - 2) << 8 | *(start + foundLen - 1);
-
-  uint16_t recalculatedCrc = CRC::crc16ccitt(start, foundLen - 2);
-
-  if (receivedCrc != recalculatedCrc) {
-    return CRC_FAILURE;
-  }
-
-  return RETURN_OK;
-}
-
-ReturnValue_t PlocMPSoCHandler::handleAckReport(const uint8_t* data) {
-  ReturnValue_t result = RETURN_OK;
-
-  result = verifyPacket(data, PLOC_MPSOC::SIZE_ACK_REPORT);
-  if (result == CRC_FAILURE) {
-    sif::error << "PlocMPSoCHandler::handleAckReport: CRC failure" << std::endl;
-    nextReplyId = PLOC_MPSOC::NONE;
-    replyRawReplyIfnotWiretapped(data, PLOC_MPSOC::SIZE_ACK_REPORT);
-    triggerEvent(CRC_FAILURE_EVENT);
-    sendFailureReport(PLOC_MPSOC::ACK_REPORT, CRC_FAILURE);
-    disableAllReplies();
-    return IGNORE_REPLY_DATA;
-  }
-
-  uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK;
-
-  switch (apid) {
-    case PLOC_MPSOC::APID_ACK_FAILURE: {
-      // TODO: Interpretation of status field in acknowledgment report
-      sif::debug << "PlocMPSoCHandler::handleAckReport: Received Ack failure report" << std::endl;
-      DeviceCommandId_t commandId = getPendingCommand();
-      if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
-        triggerEvent(ACK_FAILURE, commandId);
-      }
-      sendFailureReport(PLOC_MPSOC::ACK_REPORT, RECEIVED_ACK_FAILURE);
-      disableAllReplies();
-      nextReplyId = PLOC_MPSOC::NONE;
-      result = IGNORE_REPLY_DATA;
-      break;
-    }
-    case PLOC_MPSOC::APID_ACK_SUCCESS: {
-      setNextReplyId();
-      break;
-    }
-    default: {
-      sif::debug << "PlocMPSoCHandler::handleAckReport: Invalid APID in Ack report" << std::endl;
-      result = RETURN_FAILED;
-      break;
-    }
-  }
-
-  return result;
-}
-
-ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) {
-  ReturnValue_t result = RETURN_OK;
-
-  result = verifyPacket(data, PLOC_MPSOC::SIZE_EXE_REPORT);
-  if (result == CRC_FAILURE) {
-    sif::error << "PlocMPSoCHandler::handleExecutionReport: CRC failure" << std::endl;
-    nextReplyId = PLOC_MPSOC::NONE;
-    return result;
-  }
-
-  uint16_t apid = (*(data) << 8 | *(data + 1)) & APID_MASK;
-
-  switch (apid) {
-    case (PLOC_MPSOC::APID_EXE_SUCCESS): {
-      break;
-    }
-    case (PLOC_MPSOC::APID_EXE_FAILURE): {
-      // TODO: Interpretation of status field in execution report
-      sif::error << "PlocMPSoCHandler::handleExecutionReport: Received execution failure report"
-                 << std::endl;
-      DeviceCommandId_t commandId = getPendingCommand();
-      if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
-        triggerEvent(EXE_FAILURE, commandId);
-      } else {
-        sif::debug << "PlocMPSoCHandler::handleExecutionReport: Unknown command id" << std::endl;
-      }
-      sendFailureReport(PLOC_MPSOC::EXE_REPORT, RECEIVED_EXE_FAILURE);
-      disableExeReportReply();
-      result = IGNORE_REPLY_DATA;
-      break;
-    }
-    default: {
-      sif::error << "PlocMPSoCHandler::handleExecutionReport: Unknown APID" << std::endl;
-      result = RETURN_FAILED;
-      break;
-    }
-  }
-
-  nextReplyId = PLOC_MPSOC::NONE;
-
-  return result;
-}
-
-ReturnValue_t PlocMPSoCHandler::handleMemoryReadReport(const uint8_t* data) {
-  ReturnValue_t result = RETURN_OK;
-
-  result = verifyPacket(data, PLOC_MPSOC::SIZE_TM_MEM_READ_REPORT);
-
-  if (result == CRC_FAILURE) {
-    sif::error << "PlocMPSoCHandler::handleMemoryReadReport: Memory read report has invalid crc"
-               << std::endl;
-  }
-  /** Send data to commanding queue */
-  handleDeviceTM(data + PLOC_MPSOC::DATA_FIELD_OFFSET, PLOC_MPSOC::SIZE_MEM_READ_REPORT_DATA,
-                 PLOC_MPSOC::TM_MEMORY_READ_REPORT);
-
-  nextReplyId = PLOC_MPSOC::EXE_REPORT;
-
-  return result;
-}
-
-ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator command,
-                                                      uint8_t expectedReplies, bool useAlternateId,
-                                                      DeviceCommandId_t alternateReplyID) {
-  ReturnValue_t result = RETURN_OK;
-
-  uint8_t enabledReplies = 0;
-
-  switch (command->first) {
-    case PLOC_MPSOC::TC_MEM_WRITE:
-      enabledReplies = 2;
-      break;
-    case PLOC_MPSOC::TC_MEM_READ: {
-      enabledReplies = 3;
-      result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
-                                                        PLOC_MPSOC::TM_MEMORY_READ_REPORT);
-      if (result != RETURN_OK) {
-        sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id "
-                   << PLOC_MPSOC::TM_MEMORY_READ_REPORT << " not in replyMap" << std::endl;
-      }
-      break;
-    }
-    default:
-      sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Unknown command id" << std::endl;
-      break;
-  }
-
-  /**
-   * Every command causes at least one acknowledgment and one execution report. Therefore both
-   * replies will be enabled here.
-   */
-  result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
-                                                    PLOC_MPSOC::ACK_REPORT);
-  if (result != RETURN_OK) {
-    sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id "
-               << PLOC_MPSOC::ACK_REPORT << " not in replyMap" << std::endl;
-  }
-
-  result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
-                                                    PLOC_MPSOC::EXE_REPORT);
-  if (result != RETURN_OK) {
-    sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id "
-               << PLOC_MPSOC::EXE_REPORT << " not in replyMap" << std::endl;
-  }
-
-  return RETURN_OK;
-}
-
-void PlocMPSoCHandler::setNextReplyId() {
-  switch (getPendingCommand()) {
-    case PLOC_MPSOC::TC_MEM_READ:
-      nextReplyId = PLOC_MPSOC::TM_MEMORY_READ_REPORT;
-      break;
-    default:
-      /* If no telemetry is expected the next reply is always the execution report */
-      nextReplyId = PLOC_MPSOC::EXE_REPORT;
-      break;
-  }
-}
-size_t PlocMPSoCHandler::getNextReplyLength(DeviceCommandId_t commandId) {
-  size_t replyLen = 0;
-
-  if (nextReplyId == PLOC_MPSOC::NONE) {
-    return replyLen;
-  }
-
-  DeviceReplyIter iter = deviceReplyMap.find(nextReplyId);
-  if (iter != deviceReplyMap.end()) {
-    if (iter->second.delayCycles == 0) {
-      /* Reply inactive */
-      return replyLen;
-    }
-    replyLen = iter->second.replyLen;
-  } else {
-    sif::debug << "PlocMPSoCHandler::getNextReplyLength: No entry for reply with reply id "
-               << std::hex << nextReplyId << " in deviceReplyMap" << std::endl;
-  }
-
-  return replyLen;
-}
-
-void PlocMPSoCHandler::handleDeviceTM(const uint8_t* data, size_t dataSize,
-                                      DeviceCommandId_t replyId) {
-  ReturnValue_t result = RETURN_OK;
-
-  if (wiretappingMode == RAW) {
-    /* Data already sent in doGetRead() */
-    return;
-  }
-
-  DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
-  if (iter == deviceReplyMap.end()) {
-    sif::debug << "PlocMPSoCHandler::handleDeviceTM: Unknown reply id" << std::endl;
-    return;
-  }
-  MessageQueueId_t queueId = iter->second.command->second.sendReplyTo;
-
-  if (queueId == NO_COMMANDER) {
-    return;
-  }
-
-  result = actionHelper.reportData(queueId, replyId, data, dataSize);
-  if (result != RETURN_OK) {
-    sif::debug << "PlocMPSoCHandler::handleDeviceTM: Failed to report data" << std::endl;
-  }
-}
-
-void PlocMPSoCHandler::disableAllReplies() {
-  DeviceReplyMap::iterator iter;
-
-  /* Disable ack reply */
-  iter = deviceReplyMap.find(PLOC_MPSOC::ACK_REPORT);
-  DeviceReplyInfo* info = &(iter->second);
-  info->delayCycles = 0;
-  info->command = deviceCommandMap.end();
-
-  DeviceCommandId_t commandId = getPendingCommand();
-
-  /* If the command expects a telemetry packet the appropriate tm reply will be disabled here */
-  switch (commandId) {
-    case PLOC_MPSOC::TC_MEM_WRITE:
-      break;
-    case PLOC_MPSOC::TC_MEM_READ: {
-      iter = deviceReplyMap.find(PLOC_MPSOC::TM_MEMORY_READ_REPORT);
-      info = &(iter->second);
-      info->delayCycles = 0;
-      info->command = deviceCommandMap.end();
-      break;
-    }
-    default: {
-      sif::debug << "PlocMPSoCHandler::disableAllReplies: Unknown command id" << commandId
-                 << std::endl;
-      break;
-    }
-  }
-
-  /* We must always disable the execution report reply here */
-  disableExeReportReply();
-}
-
-void PlocMPSoCHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status) {
-  DeviceReplyIter iter = deviceReplyMap.find(replyId);
-
-  if (iter == deviceReplyMap.end()) {
-    sif::debug << "PlocMPSoCHandler::sendFailureReport: Reply not in reply map" << std::endl;
-    return;
-  }
-
-  DeviceCommandInfo* info = &(iter->second.command->second);
-
-  if (info == nullptr) {
-    sif::debug << "PlocMPSoCHandler::sendFailureReport: Reply has no active command" << std::endl;
-    return;
-  }
-
-  if (info->sendReplyTo != NO_COMMANDER) {
-    actionHelper.finish(false, info->sendReplyTo, iter->first, status);
-  }
-  info->isExecuting = false;
-}
-
-void PlocMPSoCHandler::disableExeReportReply() {
-  DeviceReplyIter iter = deviceReplyMap.find(PLOC_MPSOC::EXE_REPORT);
-  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 = 0;
-}
-
-ReturnValue_t PlocMPSoCHandler::checkPacketSequenceCount(const uint8_t* data) {
-  uint16_t receivedSequenceCount = (*(data + 2) << 8 | *(data + 3)) & PACKET_SEQUENCE_COUNT_MASK;
-  uint16_t expectedPacketSequenceCount = ((packetSequenceCount + 1) & PACKET_SEQUENCE_COUNT_MASK);
-  if (receivedSequenceCount != expectedPacketSequenceCount) {
-    sif::debug << "PlocMPSoCHandler::checkPacketSequenceCount: Packet sequence count mismatch. "
-               << std::endl;
-    sif::debug << "Received sequence count: " << receivedSequenceCount << ". OBSW sequence "
-               << "count: " << expectedPacketSequenceCount << std::endl;
-  }
-  packetSequenceCount = receivedSequenceCount;
-  return RETURN_OK;
-}

mission/devices/RwHandler.cpp

@@ -30,12 +30,7 @@ void RwHandler::doStartUp() {
   if (gpioComIF->pullHigh(enableGpio) != RETURN_OK) {
     sif::debug << "RwHandler::doStartUp: Failed to pull enable gpio to high";
   }
-
-#if OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP == 1
-  setMode(MODE_NORMAL);
-#else
   setMode(_MODE_TO_ON);
-#endif
 }
 
 void RwHandler::doShutDown() {
@@ -472,52 +467,52 @@ void RwHandler::handleGetTelemetryReply(const uint8_t* packet) {
   tmDataset.spiTotalNumOfErrors = *(packet + offset + 3) << 24 | *(packet + offset + 2) << 16 |
                                   *(packet + offset + 1) << 8 | *(packet + offset);
 #if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_RW == 1
-  sif::info << "RwHandler::handleTemperatureReply: Last reset status: "
+  sif::info << "RwHandler::handleGetTelemetryReply: Last reset status: "
             << static_cast<unsigned int>(tmDataset.lastResetStatus.value) << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: MCU temperature: " << tmDataset.mcuTemperature
+  sif::info << "RwHandler::handleGetTelemetryReply: MCU temperature: " << tmDataset.mcuTemperature
             << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: Pressure sensor temperature: "
+  sif::info << "RwHandler::handleGetTelemetryReply: Pressure sensor temperature: "
             << tmDataset.pressureSensorTemperature << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: Pressure " << tmDataset.pressure << std::endl;
+  sif::info << "RwHandler::handleGetTelemetryReply: Pressure " << tmDataset.pressure << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: State: "
+  sif::info << "RwHandler::handleGetTelemetryReply: State: "
             << static_cast<unsigned int>(tmDataset.rwState.value) << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: CLC mode: "
+  sif::info << "RwHandler::handleGetTelemetryReply: CLC mode: "
             << static_cast<unsigned int>(tmDataset.rwClcMode.value) << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: Current speed: " << tmDataset.rwCurrSpeed
+  sif::info << "RwHandler::handleGetTelemetryReply: Current speed: " << tmDataset.rwCurrSpeed
             << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: Reference speed: " << tmDataset.rwRefSpeed
+  sif::info << "RwHandler::handleGetTelemetryReply: Reference speed: " << tmDataset.rwRefSpeed
             << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: Number of invalid CRC packets: "
+  sif::info << "RwHandler::handleGetTelemetryReply: Number of invalid CRC packets: "
             << tmDataset.numOfInvalidCrcPackets << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: Number of invalid length packets: "
+  sif::info << "RwHandler::handleGetTelemetryReply: Number of invalid length packets: "
             << tmDataset.numOfInvalidLenPackets << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: Number of invalid command packets: "
+  sif::info << "RwHandler::handleGetTelemetryReply: Number of invalid command packets: "
             << tmDataset.numOfInvalidCmdPackets << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: Number of command executed replies: "
+  sif::info << "RwHandler::handleGetTelemetryReply: Number of command executed replies: "
             << tmDataset.numOfCmdExecutedReplies << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: Number of command replies: "
+  sif::info << "RwHandler::handleGetTelemetryReply: Number of command replies: "
             << tmDataset.numOfCmdReplies << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: UART number of bytes written: "
+  sif::info << "RwHandler::handleGetTelemetryReply: UART number of bytes written: "
             << tmDataset.uartNumOfBytesWritten << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: UART number of bytes read: "
+  sif::info << "RwHandler::handleGetTelemetryReply: UART number of bytes read: "
             << tmDataset.uartNumOfBytesRead << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: UART number of parity errors: "
+  sif::info << "RwHandler::handleGetTelemetryReply: UART number of parity errors: "
             << tmDataset.uartNumOfParityErrors << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: UART number of noise errors: "
+  sif::info << "RwHandler::handleGetTelemetryReply: UART number of noise errors: "
             << tmDataset.uartNumOfNoiseErrors << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: UART number of frame errors: "
+  sif::info << "RwHandler::handleGetTelemetryReply: UART number of frame errors: "
             << tmDataset.uartNumOfFrameErrors << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: UART number of register overrun errors: "
+  sif::info << "RwHandler::handleGetTelemetryReply: UART number of register overrun errors: "
             << tmDataset.uartNumOfRegisterOverrunErrors << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: UART number of total errors: "
+  sif::info << "RwHandler::handleGetTelemetryReply: UART number of total errors: "
             << tmDataset.uartTotalNumOfErrors << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: SPI number of bytes written: "
+  sif::info << "RwHandler::handleGetTelemetryReply: SPI number of bytes written: "
             << tmDataset.spiNumOfBytesWritten << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: SPI number of bytes read: "
+  sif::info << "RwHandler::handleGetTelemetryReply: SPI number of bytes read: "
             << tmDataset.spiNumOfBytesRead << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: SPI number of register overrun errors: "
+  sif::info << "RwHandler::handleGetTelemetryReply: SPI number of register overrun errors: "
             << tmDataset.spiNumOfRegisterOverrunErrors << std::endl;
-  sif::info << "RwHandler::handleTemperatureReply: SPI number of register total errors: "
+  sif::info << "RwHandler::handleGetTelemetryReply: SPI number of register total errors: "
             << tmDataset.spiTotalNumOfErrors << std::endl;
 #endif
 }

mission/devices/devicedefinitions/PlocMPSoCDefinitions.h

@@ -1,166 +0,0 @@
-#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
-#define MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
-
-#include <fsfw/globalfunctions/CRC.h>
-#include <fsfw/serialize/SerializeAdapter.h>
-#include <fsfw/tmtcpacket/SpacePacket.h>
-
-namespace PLOC_MPSOC {
-
-static const DeviceCommandId_t NONE = 0x0;
-static const DeviceCommandId_t TC_MEM_WRITE = 0x1;
-static const DeviceCommandId_t TC_MEM_READ = 0x2;
-static const DeviceCommandId_t ACK_REPORT = 0x3;
-static const DeviceCommandId_t EXE_REPORT = 0x5;
-static const DeviceCommandId_t TM_MEMORY_READ_REPORT = 0x6;
-
-static const uint16_t SIZE_ACK_REPORT = 14;
-static const uint16_t SIZE_EXE_REPORT = 14;
-static const uint16_t SIZE_TM_MEM_READ_REPORT = 18;
-
-/**
- * SpacePacket apids of PLOC telecommands and telemetry.
- */
-static const uint16_t APID_TC_MEM_WRITE = 0x714;
-static const uint16_t APID_TC_MEM_READ = 0x715;
-static const uint16_t APID_TM_MEMORY_READ_REPORT = 0x404;
-static const uint16_t APID_ACK_SUCCESS = 0x400;
-static const uint16_t APID_ACK_FAILURE = 0x401;
-static const uint16_t APID_EXE_SUCCESS = 0x402;
-static const uint16_t APID_EXE_FAILURE = 0x403;
-
-/** Offset from first byte in Space packet to first byte of data field */
-static const uint8_t DATA_FIELD_OFFSET = 6;
-
-/**
- * The size of payload data which will be forwarded to the requesting object. e.g. PUS Service
- * 8.
- */
-static const uint8_t SIZE_MEM_READ_REPORT_DATA = 10;
-
-/**
- * PLOC space packet length for fixed size packets. This is the size of the whole packet data
- * field. For the length field in the space packet this size will be substracted by one.
- */
-static const uint16_t LENGTH_TC_MEM_WRITE = 12;
-static const uint16_t LENGTH_TC_MEM_READ = 8;
-
-static const size_t MAX_REPLY_SIZE = SIZE_TM_MEM_READ_REPORT;
-static const size_t MAX_COMMAND_SIZE = 18;
-
-/**
- * @brief   This class helps to build the memory read command for the PLOC.
- *
- * @details The last two bytes of the packet data field contain a CRC calculated over the whole
- *          space packet. This is the CRC-16-CCITT as specified in
- *          ECSS-E-ST-70-41C Telemetry and telecommand packet utilization.
- */
-class TcMemRead : public SpacePacket {
- public:
-  /**
-   * @brief   Constructor
-   *
-   * @param memAddr   The memory address to read from.
-   */
-  TcMemRead(const uint32_t memAddr, uint16_t sequenceCount)
-      : SpacePacket(LENGTH_TC_MEM_READ - 1, true, APID_TC_MEM_READ, sequenceCount) {
-    fillPacketDataField(&memAddr);
-  }
-
- private:
-  /**
-   * @brief   This function builds the packet data field for the mem read command.
-   *
-   * @param memAddrPtr    Pointer to the memory address to read from.
-   */
-  void fillPacketDataField(const uint32_t* memAddrPtr) {
-    /* Add memAddr to packet data field */
-    size_t serializedSize = 0;
-    uint8_t* memoryAddressPos = this->localData.fields.buffer;
-    SerializeAdapter::serialize<uint32_t>(memAddrPtr, &memoryAddressPos, &serializedSize,
-                                          sizeof(*memAddrPtr), SerializeIF::Endianness::LITTLE);
-
-    /* Add memLen to packet data field */
-    this->localData.fields.buffer[OFFSET_MEM_LEN_FIELD] = 1;
-    this->localData.fields.buffer[OFFSET_MEM_LEN_FIELD + 1] = 0;
-
-    /* Calculate crc */
-    uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
-                                   sizeof(CCSDSPrimaryHeader) + LENGTH_TC_MEM_READ - CRC_SIZE);
-
-    /* Add crc to packet data field of space packet */
-    serializedSize = 0;
-    uint8_t* crcPos = this->localData.fields.buffer + CRC_OFFSET;
-    SerializeAdapter::serialize<uint16_t>(&crc, &crcPos, &serializedSize, sizeof(crc),
-                                          SerializeIF::Endianness::BIG);
-  }
-
-  static const uint8_t OFFSET_MEM_LEN_FIELD = 4;
-  static const uint8_t CRC_OFFSET = 6;
-};
-
-/**
- * @brief   This class helps to generate the space packet to write to a memory address within
- *          the PLOC.
- * @details The last two bytes of the packet data field contain a CRC calculated over the whole
- *          space packet. This is the CRC-16-CCITT as specified in
- *          ECSS-E-ST-70-41C Telemetry and telecommand packet utilization.
- */
-class TcMemWrite : public SpacePacket {
- public:
-  /**
-   * @brief   Constructor
-   *
-   * @param memAddr   The PLOC memory address where to write to.
-   * @param memoryData    The data to write to the specified memory address.
-   * @param sequenceCount The subsequence count. Must be incremented with each new packet.
-   */
-  TcMemWrite(const uint32_t memAddr, const uint32_t memoryData, uint16_t sequenceCount)
-      : SpacePacket(LENGTH_TC_MEM_WRITE - 1, true, APID_TC_MEM_WRITE, sequenceCount) {
-    fillPacketDataField(&memAddr, &memoryData);
-  }
-
- private:
-  /**
-   * @brief   This function builds the packet data field for the mem write command.
-   *
-   * @param memAddrPtr    Pointer to the PLOC memory address where to write to.
-   * @param memoryDataPtr    Pointer to the memoryData to write
-   */
-  void fillPacketDataField(const uint32_t* memAddrPtr, const uint32_t* memoryDataPtr) {
-    /* Add memAddr to packet data field */
-    size_t serializedSize = 0;
-    uint8_t* memoryAddressPos = this->localData.fields.buffer;
-    SerializeAdapter::serialize<uint32_t>(memAddrPtr, &memoryAddressPos, &serializedSize,
-                                          sizeof(*memAddrPtr), SerializeIF::Endianness::BIG);
-
-    /* Add memLen to packet data field */
-    this->localData.fields.buffer[OFFSET_MEM_LEN_FIELD] = 1;
-    this->localData.fields.buffer[OFFSET_MEM_LEN_FIELD + 1] = 0;
-
-    /* Add memData to packet data field */
-    serializedSize = 0;
-    uint8_t* memoryDataPos = this->localData.fields.buffer + OFFSET_MEM_DATA_FIELD;
-    SerializeAdapter::serialize<uint32_t>(memoryDataPtr, &memoryDataPos, &serializedSize,
-                                          sizeof(*memoryDataPtr), SerializeIF::Endianness::BIG);
-
-    /* Calculate crc */
-    uint16_t crc = CRC::crc16ccitt(this->localData.byteStream,
-                                   sizeof(CCSDSPrimaryHeader) + LENGTH_TC_MEM_WRITE - CRC_SIZE);
-
-    serializedSize = 0;
-    uint8_t* crcPos = this->localData.fields.buffer + CRC_OFFSET;
-    /* Add crc to packet data field of space packet */
-    SerializeAdapter::serialize<uint16_t>(&crc, &crcPos, &serializedSize, sizeof(crc),
-                                          SerializeIF::Endianness::BIG);
-  }
-
-  /** Offsets from base address of packet data field */
-  static const uint8_t OFFSET_MEM_LEN_FIELD = 4;
-  static const uint8_t OFFSET_MEM_DATA_FIELD = 6;
-  static const uint8_t CRC_OFFSET = 10;
-};
-
-}  // namespace PLOC_MPSOC
-
-#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ */

mission/devices/devicedefinitions/payloadPcduDefinitions.h

@@ -152,7 +152,7 @@ static constexpr double DFT_MPA_I_UPPER_BOUND = 650.0;
 
 static constexpr double DFT_HPA_U_LOWER_BOUND = 9.4;
 static constexpr double DFT_HPA_U_UPPER_BOUND = 11.0;
-static constexpr double DFT_HPA_I_UPPER_BOUND = 3000.0;
+static constexpr double DFT_HPA_I_UPPER_BOUND = 3800.0;
 
 // Wait time in floating point seconds
 static constexpr double DFT_SSR_TO_DRO_WAIT_TIME = 5.0;

mission/tmtc/CCSDSHandler.cpp

@@ -313,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 */
@@ -332,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 */

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,16 @@
+#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,27 @@
+#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_ */