CHANGELOG.md

@@ -10,8 +10,46 @@ list yields a list of all related PRs for each release.
 
 # [unreleased]
 
-# [v1.14.0]
+- Add IRQ mode for PDEC handler
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/310
+- Extended TM funnels to allow multiple TM recipients.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/312
+- DHB: Transitions to normal mode now possible directly, which simplifies subsystem implementations
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/313
+- MAX3185 Low Level Handler and Device Handler: Simplifications and bugfixes to allow switching
+  off without triggering unrequested replies
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/313
 
+# [v1.15.0] 27.10.2022
+
+- Consistent device file naming
+- Remove rad sensor from EM build, lead to weird bugs on EM which
+  prevented `xsc_boot_copy` from working properly
+- CFDP closure handling is now working
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/307
+- Safety mechanism for SD card handling on graceful reboots
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/308
+- Solar Array Deployment handler update
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/305
+- IMTQ updates as preparation for ACS controller expansion
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/306
+- P60 Module: Reduce number of set IDs, use same set IDs for core, auxiliary
+  and config HK set across the three PCDU modules
+
+# [v1.14.1] 11.10.2022
+
+- Various bugfixes and regression fixes
+- General file handling at program initialization now works properly again
+- Scratch buffer preferred SD card handling works again
+- Use scoped locks in TCS controller to avoid deadlocks
+
+# [v1.14.0] 10.10.2022
+
+- Provide full SW update capability for the OBSW.
+  This includes very basic CFDP integration, a software update
+  procedure specified in detail in the README and some high level
+  commands to make this easier for operators.
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/302
 - Update for FSFW: `HasReturnvaluesIF` class replaced by namespace `returnvalue`
 - Add some GomSpace clients as a submodule dependency. Use this dependency to deserialize the
   GomSpace TM tables
@@ -22,6 +60,9 @@ list yields a list of all related PRs for each release.
 - Increase number of allowed consescutive action commands from 3 to 16
   PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/294
 - Fix for EM SW: Always create ACS Task
+- Added Scex device handler and Scex uart reader
+  PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/303
+- ACS Subsystem. PR: https://egit.irs.uni-stuttgart.de/eive/eive-obsw/pulls/228
 
 # [v1.13.0] 24.08.2022
 

CMakeLists.txt

@@ -10,7 +10,7 @@
 cmake_minimum_required(VERSION 3.13)
 
 set(OBSW_VERSION_MAJOR_IF_GIT_FAILS 1)
-set(OBSW_VERSION_MINOR_IF_GIT_FAILS 13)
+set(OBSW_VERSION_MINOR_IF_GIT_FAILS 15)
 set(OBSW_VERSION_REVISION_IF_GIT_FAILS 0)
 
 # set(CMAKE_VERBOSE TRUE)
@@ -98,11 +98,35 @@ set(OBSW_ADD_ACS_BOARD
 set(OBSW_ADD_GPS_CTRL
     ${INIT_VAL}
     CACHE STRING "Add GPS controllers")
+set(OBSW_ADD_CCSDS_IP_CORES
+    1
+    CACHE STRING "Add CCSDS IP cores")
+set(OBSW_TM_TO_PTME
+    1
+    CACHE STRING "Send telemetry to PTME IP core")
+set(OBSW_TC_FROM_PDEC
+    1
+    CACHE STRING "Poll telecommand from PDEC IP core")
+set(OBSW_ADD_TCS_CTRL
+    ${INIT_VAL}
+    CACHE STRING "Add TCS controllers")
+set(OBSW_ADD_HEATERS
+    ${INIT_VAL}
+    CACHE STRING "Add TCS heaters")
+set(OBSW_ADD_PLOC_SUPERVISOR
+    ${INIT_VAL}
+    CACHE STRING "Add PLOC supervisor handler")
+set(OBSW_ADD_SA_DEPL
+    ${INIT_VAL}
+    CACHE STRING "Add SA deployment handler")
+set(OBSW_ADD_PLOC_MPSOC
+    ${INIT_VAL}
+    CACHE STRING "Add MPSoC handler")
 set(OBSW_ADD_ACS_CTRL
     ${INIT_VAL}
     CACHE STRING "Add ACS controller")
 set(OBSW_ADD_RTD_DEVICES
-    1
+    ${INIT_VAL}
     CACHE STRING "Add RTD devices")
 set(OBSW_ADD_RAD_SENSORS
     ${INIT_VAL}
@@ -122,6 +146,12 @@ set(OBSW_ADD_GOMSPACE_PCDU
 set(OBSW_ADD_RW
     ${INIT_VAL}
     CACHE STRING "Add RW modules")
+set(OBSW_ADD_SCEX_DEVICE
+    ${INIT_VAL}
+    CACHE STRING "Add Solar Cell Experiment module")
+set(OBSW_SYRLINKS_SIMULATED
+    ${OBSW_Q7S_EM}
+    CACHE STRING "Syrlinks is simulated")
 
 # ##############################################################################
 # Pre-Sources preparation
@@ -370,7 +400,11 @@ if(EIVE_ADD_LINUX_FILES)
   add_subdirectory(${LINUX_PATH})
 endif()
 add_subdirectory(${BSP_PATH})
-add_subdirectory(${LIB_GOMSPACE_PATH})
+
+if(UNIX)
+  add_subdirectory(${LIB_GOMSPACE_PATH})
+endif()
+
 add_subdirectory(${COMMON_PATH})
 add_subdirectory(${DUMMY_PATH})
 
@@ -382,21 +416,19 @@ add_subdirectory(${TEST_PATH})
 add_subdirectory(${UNITTEST_PATH})
 
 # This should have already been downloaded by the FSFW Still include it to be
-# safe
+# safe find_package(etl ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET) Not
-find_package(etl ${FSFW_ETL_LIB_MAJOR_VERSION} CONFIG QUIET)
+# installed, so use FetchContent to download and provide etl if(NOT etl_FOUND)
-# Not installed, so use FetchContent to download and provide etl
+message(
-if(NOT etl_FOUND)
-  message(
   STATUS
     "No ETL installation was found with find_package. Installing and providing "
     "etl with FindPackage")
-  include(FetchContent)
+include(FetchContent)
-  FetchContent_Declare(
+FetchContent_Declare(
   etl
   GIT_REPOSITORY https://github.com/ETLCPP/etl
   GIT_TAG ${FSFW_ETL_LIB_VERSION})
-  list(APPEND FSFW_FETCH_CONTENT_TARGETS etl)
+list(APPEND FSFW_FETCH_CONTENT_TARGETS etl)
-endif()
+# endif()
 
 # Use same Catch2 version as framework
 if(NOT (TGT_BSP MATCHES "arm/te0720-1cfa")
@@ -454,17 +486,16 @@ if(TGT_BSP MATCHES "arm/q7s")
   target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_GPS} ${LIB_ARCSEC})
 endif()
 
-target_link_libraries(
+target_link_libraries(${UNITTEST_NAME} PRIVATE Catch2 ${LIB_EIVE_MISSION}
-  ${UNITTEST_NAME} PRIVATE Catch2 ${LIB_EIVE_MISSION} rapidcsv ${LIB_DUMMIES}
+                                               rapidcsv ${LIB_DUMMIES})
-                           ${LIB_GOMSPACE_CLIENTS})
 
 if(TGT_BSP MATCHES "arm/egse")
   target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_ARCSEC})
 endif()
 
-target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_GOMSPACE_CLIENTS})
+if(UNIX)
-target_link_libraries(${LIB_EIVE_MISSION} PRIVATE ${LIB_GOMSPACE_CLIENTS})
+  target_link_libraries(${OBSW_NAME} PRIVATE ${LIB_GOMSPACE_CLIENTS})
-target_link_libraries(${LIB_DUMMIES} PRIVATE ${LIB_GOMSPACE_CLIENTS})
+endif()
 
 if(EIVE_ADD_ETL_LIB)
   target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_ETL_TARGET})

README.md

@@ -152,6 +152,78 @@ When using Windows, run theses steps in MSYS2.
    cmake --build . -j
    ```
 
+## Preparing and executing an OBSW update
+
+A OBSW update consists of a `xz` compressed file `eive-sw-update.tar.xz`
+which contains the following two files:
+
+1. Stripped OBSW binary `eive-obsw-stripped`
+2. OBSW version text file with the name `obsw_version.txt`
+
+These files can be created manually:
+
+1. Build the release image inside `cmake-build-release-q7s`
+2. Switch into the build directory
+3. Run the following command to create the version file
+
+   ```sh
+   git describe --tags --always --exclude docker_* > obsw_version.txt
+   ```
+
+   You can also use the `create-version-file.sh` helper shell script
+   located in the `scripts` folder to do this.
+
+4. Set the Q7S user as the file owner for both files
+
+   ```sh
+   sudo chown root:root eive-obsw-stripped
+   sudo chown root:root obsw_version.txt
+   ```
+
+5. Run the following command to create the compressed archive
+
+   ```sh
+   tar -cJvf eive-sw-update.tar.xz eive-obsw-stripped obsw_version.txt
+   ```
+
+You can also use the helper script `create-sw-update.sh` inside the build folder
+after sourcing the `q7s-env.sh` helper script to perform all steps including
+a rebuild.
+
+After creating these files, they need to be transferred onto the Q7S
+to either the `/mnt/sd0/bin` or `/mnt/sd1/bin` folder if the OBSW update
+is performed from the SD card. It can also be transferred to the `/tmp` folder
+to perform the update from a temporary directory, which does not rely on any
+of the SD cards being on and mounted. However, all files in the temporary
+directory will be deleted if the Linux OS is rebooted for any reason.
+
+After both files are in place (this is checked by the OBSW), the example command
+sequence is used by the OBSW to write the OBSW update to the QSPI chip 0 and
+slot 0 using SD card 0:
+
+```sh
+tar -xJvf eive-update.tar.xz
+xsc_mount_copy 0 0
+cp eive-obsw-stripped /tmp/mntupdate-xdi-qspi0-nom-rootfs/usr/bin/eive-obsw
+cp obsw_update.txt /tmp/mntupdate-xdi-qspi0-nom-rootfs/usr/share/obsw_update.txt
+writeprotect 0 0 1
+```
+
+Some context information about the used commands:
+
+1. It mounts the target chip and copy combination into the `/tmp` folder
+   using the `xsc_mount_copy <chip> <copy>` utility. This also unlocks the
+   writeprotection for the chip. The mount point name inside `/tmp` depends
+   on which chip and copy is used
+
+   - Chip 0 Copy 0: `/tmp/mntupdate-xdi-qspi0-nom-rootfs`
+   - Chip 0 Copy 1: `/tmp/mntupdate-xdi-qspi0-gold-rootfs`
+   - Slot 1 Copy 0: `/tmp/mntupdate-xdi-qspi1-nom-rootfs`
+   - Slot 1 Copy 1: `/tmp/mntupdate-xdi-qspi1-gold-rootfs`
+
+2. Writing the file with a regular `cp <source> <target>` command
+3. Enabling the writeprotection using the `writeprotect <chip> <copy> 1` utility.
+
 ## Build for the Q7S target root filesystem with `yocto`
 
 The EIVE root filesystem will contain the EIVE OBSW and the Watchdog component.

bsp_hosted/ObjectFactory.cpp

@@ -4,12 +4,12 @@
 #include <fsfw/tmtcservices/PusServiceBase.h>
 #include <mission/controller/ThermalController.h>
 #include <mission/core/GenericFactory.h>
-#include <mission/tmtc/TmFunnel.h>
+#include <mission/tmtc/TmFunnelHandler.h>
 #include <objects/systemObjectList.h>
-#include <tmtc/apid.h>
 #include <tmtc/pusIds.h>
 
 #include "OBSWConfig.h"
+#include "eive/definitions.h"
 #include "fsfw_tests/integration/task/TestTask.h"
 
 #if OBSW_USE_TMTC_TCP_BRIDGE == 0
@@ -45,6 +45,7 @@
 #include <dummies/TemperatureSensorsDummy.h>
 
 #include "dummies/helpers.h"
+#include "mission/utility/GlobalConfigHandler.h"
 
 void Factory::setStaticFrameworkObjectIds() {
   PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
@@ -53,22 +54,19 @@ void Factory::setStaticFrameworkObjectIds() {
   CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
   CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
 
-  TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
-  // No storage object for now.
-  TmFunnel::storageDestination = objects::NO_OBJECT;
-
   VerificationReporter::DEFAULT_RECEIVER = objects::PUS_SERVICE_1_VERIFICATION;
 }
 
 void ObjectFactory::produce(void* args) {
   Factory::setStaticFrameworkObjectIds();
-  ObjectFactory::produceGenericObjects();
+  PusTmFunnel* pusFunnel;
+  CfdpTmFunnel* cfdpFunnel;
+  ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel);
 
   dummy::DummyCfg cfg;
   dummy::createDummies(cfg);
   new TemperatureSensorsDummy();
   new SusDummy();
-  new ThermalController(objects::THERMAL_CONTROLLER, objects::NO_OBJECT);
+  new ThermalController(objects::THERMAL_CONTROLLER);
-
+  new TestTask(objects::TEST_TASK);
-  // new TestTask(objects::TEST_TASK);
 }

bsp_hosted/fsfwconfig/OBSWConfig.h.in

@@ -16,7 +16,7 @@
 debugging. */
 #define OBSW_VEBOSE_LEVEL                           1
 
-#define OBSW_USE_CCSDS_IP_CORE                      0
+#define OBSW_ADD_CCSDS_IP_CORES                     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

bsp_hosted/fsfwconfig/events/subsystemIdRanges.h

@@ -1,10 +1,10 @@
 #ifndef CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
 #define CONFIG_EVENTS_SUBSYSTEMIDRANGES_H_
 
-#include <common/config/commonSubsystemIds.h>
-
 #include <cstdint>
 
+#include "eive/eventSubsystemIds.h"
+
 /**
  * These IDs are part of the ID for an event thrown by a subsystem.
  * Numbers 0-80 are reserved for FSFW Subsystem IDs (framework/events/)

bsp_hosted/fsfwconfig/objects/systemObjectList.h

@@ -1,10 +1,10 @@
 #ifndef HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
 #define HOSTED_CONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
 
-#include <commonObjects.h>
-
 #include <cstdint>
 
+#include "eive/objects.h"
+
 // The objects will be instantiated in the ID order
 namespace objects {
 enum sourceObjects : uint32_t {
@@ -16,8 +16,6 @@ enum sourceObjects : uint32_t {
   PUS_SERVICE_23 = 0x51002300,
   PUS_SERVICE_201 = 0x51020100,
 
-  TM_FUNNEL = 0x52000002,
-
   /* Test Task */
 
   TEST_TASK = 0x42694269,

bsp_hosted/fsfwconfig/returnvalues/classIds.h

@@ -3,7 +3,7 @@
 
 #include <fsfw/returnvalues/FwClassIds.h>
 
-#include "commonClassIds.h"
+#include "eive/resultClassIds.h"
 
 /**
  * Source IDs starts at 73 for now

bsp_hosted/main.cpp

@@ -31,6 +31,9 @@ int main(void) {
             << "v" << common::OBSW_VERSION << " | FSFW v" << fsfw::FSFW_VERSION << " --"
             << std::endl;
   std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
+  std::cout << "-- "
+            << " BSP HOSTED"
+            << " --" << std::endl;
 
   initmission::initMission();
 

bsp_linux_board/CMakeLists.txt

@@ -1,5 +1,5 @@
 target_sources(${OBSW_NAME} PUBLIC InitMission.cpp main.cpp gpioInit.cpp
-                                   ObjectFactory.cpp)
+                                   ObjectFactory.cpp RPiSdCardManager.cpp)
 
 add_subdirectory(boardconfig)
 add_subdirectory(boardtest)

bsp_linux_board/InitMission.cpp

@@ -1,5 +1,6 @@
 #include "InitMission.h"
 
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
 #include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/objectmanager/ObjectManagerIF.h>
 #include <fsfw/returnvalues/returnvalue.h>
@@ -7,6 +8,7 @@
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 #include <fsfw/tasks/PeriodicTaskIF.h>
 #include <fsfw/tasks/TaskFactory.h>
+#include <linux/InitMission.h>
 #include <mission/utility/InitMission.h>
 
 #include <iostream>
@@ -77,6 +79,12 @@ void initmission::initTasks() {
     sif::error << "Add component TMTC Polling failed" << std::endl;
   }
 
+#if OBSW_ADD_SCEX_DEVICE == 1
+  PeriodicTaskIF* scexDevHandler;
+  PeriodicTaskIF* scexReaderTask;
+  scheduling::schedulingScex(*factory, scexDevHandler, scexReaderTask);
+#endif
+
   /* PUS Services */
   std::vector<PeriodicTaskIF*> pusTasks;
   createPusTasks(*factory, missedDeadlineFunc, pusTasks);
@@ -109,6 +117,10 @@ void initmission::initTasks() {
 #endif /* OBSW_ADD_TEST_CODE == 1 */
   taskStarter(pstTasks, "PST Tasks");
 
+#if OBSW_ADD_SCEX_DEVICE == 1
+  scexDevHandler->startTask();
+  scexReaderTask->startTask();
+#endif
 #if OBSW_ADD_TEST_PST == 1
   if (startTestPst) {
     pstTestTask->startTask();
@@ -195,9 +207,12 @@ void initmission::createPstTasks(TaskFactory& factory,
       "SPI_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
   result = pst::pstSpi(spiPst);
   if (result != returnvalue::OK) {
-    sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;
+    if (result != FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
+      sif::error << "InitMission::createPstTasks: Creating PST failed!" << std::endl;
     }
+  } else {
     taskVec.push_back(spiPst);
+  }
 #endif
 }
 
@@ -228,6 +243,13 @@ void initmission::createTestTasks(TaskFactory& factory,
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
   }
+  PeriodicTaskIF* scexReaderTask = factory.createPeriodicTask(
+      "SCEX_UART_READER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = scexReaderTask->addComponent(objects::SCEX_UART_READER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("SCEX_UART_READER", objects::SCEX_UART_READER);
+  }
+  taskVec.push_back(scexReaderTask);
 #endif /* RPI_ADD_GPIO_TEST == 1 */
   taskVec.push_back(testTask);
 

bsp_linux_board/OBSWConfig.h.in

@@ -28,6 +28,7 @@
 #define OBSW_ADD_RTD_DEVICES                        0
 #define OBSW_ADD_PL_PCDU                            0
 #define OBSW_ADD_TMP_DEVICES                        0
+#define OBSW_ADD_SCEX_DEVICE                        1
 #define OBSW_ADD_RAD_SENSORS                        0
 #define OBSW_ADD_SYRLINKS                           0
 #define OBSW_STAR_TRACKER_GROUND_CONFIG             1
@@ -102,6 +103,12 @@
 /*******************************************************************/
 #cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER
 
+#define OBSW_ADD_CCSDS_IP_CORES                     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
+
 #cmakedefine LIBGPS_VERSION_MAJOR @LIBGPS_VERSION_MAJOR@
 #cmakedefine LIBGPS_VERSION_MINOR @LIBGPS_VERSION_MINOR@
 

bsp_linux_board/ObjectFactory.cpp

@@ -1,5 +1,8 @@
 #include "ObjectFactory.h"
 
+#include <bsp_linux_board/RPiSdCardManager.h>
+#include <linux/devices/ScexUartReader.h>
+
 #include "OBSWConfig.h"
 #include "devConf.h"
 #include "devices/addresses.h"
@@ -18,9 +21,8 @@
 #include "mission/core/GenericFactory.h"
 #include "mission/devices/GPSHyperionHandler.h"
 #include "mission/devices/GyroADIS1650XHandler.h"
-#include "mission/utility/TmFunnel.h"
+#include "mission/tmtc/TmFunnel.h"
 #include "objects/systemObjectList.h"
-#include "tmtc/apid.h"
 #include "tmtc/pusIds.h"
 
 /* UDP server includes */
@@ -45,8 +47,8 @@
 #include "fsfw_hal/linux/spi/SpiCookie.h"
 
 void Factory::setStaticFrameworkObjectIds() {
-  PusServiceBase::packetSource = objects::PUS_PACKET_DISTRIBUTOR;
+  PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
-  PusServiceBase::packetDestination = objects::TM_FUNNEL;
+  PusServiceBase::PACKET_DESTINATION = objects::TM_FUNNEL;
 
   CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
   CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
@@ -54,9 +56,6 @@ void Factory::setStaticFrameworkObjectIds() {
   TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
   // No storage object for now.
   TmFunnel::storageDestination = objects::NO_OBJECT;
-
-  VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;
-  TmPacketBase::timeStamperId = objects::TIME_STAMPER;
 }
 
 void ObjectFactory::produce(void* args) {
@@ -76,12 +75,17 @@ void ObjectFactory::produce(void* args) {
   createRpiAcsBoard(gpioIF, spiDev);
 #endif
 
-#if OBSW_ADD_SUN_SENSORS == 1 || defined(OBSW_ADD_RTD_DEVICES)
+#if OBSW_ADD_SUN_SENSORS == 1 || OBSW_ADD_RTD_DEVICES == 1
 #ifdef RASPBERRY_PI
   rpi::gpio::initSpiCsDecoder(gpioIF);
 #endif
 #endif
 
+#if OBSW_ADD_SCEX_DEVICE == 1
+  auto* sdcMan = new RPiSdCardManager("/tmp");
+  createScexComponents(uart::DEV, pwrSwitcher, *sdcMan, true, std::nullopt);
+#endif
+
 #if OBSW_ADD_SUN_SENSORS == 1
   createSunSensorComponents(gpioIF, spiComIF, pwrSwitcher, spi::DEV);
 #endif

bsp_linux_board/RPiSdCardManager.cpp

@@ -0,0 +1,13 @@
+#include "RPiSdCardManager.h"
+
+RPiSdCardManager::RPiSdCardManager(std::string prefix) : prefix(std::move(prefix)) {}
+
+const std::string& RPiSdCardManager::getCurrentMountPrefix() const { return prefix; }
+
+bool RPiSdCardManager::isSdCardUsable(sd::SdCard sdCard) { return true; }
+
+std::optional<sd::SdCard> RPiSdCardManager::getPreferredSdCard() const { return std::nullopt; }
+
+void RPiSdCardManager::setActiveSdCard(sd::SdCard sdCard) {}
+
+std::optional<sd::SdCard> RPiSdCardManager::getActiveSdCard() const { return std::nullopt; }

bsp_linux_board/RPiSdCardManager.h

@@ -0,0 +1,18 @@
+#ifndef BSP_LINUX_BOARD_RPISDCARDMANAGER_H_
+#define BSP_LINUX_BOARD_RPISDCARDMANAGER_H_
+#include <mission/memory/SdCardMountedIF.h>
+
+class RPiSdCardManager : public SdCardMountedIF {
+ public:
+  RPiSdCardManager(std::string prefix);
+  const std::string& getCurrentMountPrefix() const override;
+  bool isSdCardUsable(sd::SdCard sdCard) override;
+  std::optional<sd::SdCard> getPreferredSdCard() const override;
+  void setActiveSdCard(sd::SdCard sdCard) override;
+  std::optional<sd::SdCard> getActiveSdCard() const override;
+
+ private:
+  std::string prefix;
+};
+
+#endif /* BSP_LINUX_BOARD_RPISDCARDMANAGER_H_ */

bsp_linux_board/definitions.h

@@ -13,6 +13,12 @@ static constexpr char DEV[] = "/dev/spidev0.1";
 
 }
 
+namespace uart {
+
+static constexpr char DEV[] = "/dev/serial0";
+
+}
+
 /* Adapt these values accordingly */
 namespace gpio {
 static constexpr uint8_t MGM_0_BCM_PIN = 17;

bsp_q7s/CMakeLists.txt

@@ -24,3 +24,4 @@ endif()
 add_subdirectory(memory)
 add_subdirectory(callbacks)
 add_subdirectory(xadc)
+add_subdirectory(fs)

bsp_q7s/OBSWConfig.h.in

@@ -14,32 +14,38 @@
 /** All of the following flags should be enabled for mission code  */
 /*******************************************************************/
 
-#define OBSW_USE_CCSDS_IP_CORE                      1
-// Set to 1 if all telemetry should be sent to the PTME IP Core
-#define OBSW_TM_TO_PTME                             0
-// Set to 1 if telecommands are received via the PDEC IP Core
-#define OBSW_TC_FROM_PDEC                           0
-
-#define OBSW_ENABLE_TIMERS                          1
 #define OBSW_ADD_GOMSPACE_PCDU                      @OBSW_ADD_GOMSPACE_PCDU@
 #define OBSW_ADD_MGT                                @OBSW_ADD_MGT@
 #define OBSW_ADD_BPX_BATTERY_HANDLER                @OBSW_ADD_BPX_BATTERY_HANDLER@
 #define OBSW_ADD_STAR_TRACKER                       @OBSW_ADD_STAR_TRACKER@
-#define OBSW_ADD_PLOC_SUPERVISOR                    1
+#define OBSW_ADD_PLOC_SUPERVISOR                    @OBSW_ADD_PLOC_SUPERVISOR@
-#define OBSW_ADD_PLOC_MPSOC                         1
+#define OBSW_ADD_PLOC_MPSOC                         @OBSW_ADD_PLOC_MPSOC@
 #define OBSW_ADD_SUN_SENSORS                        @OBSW_ADD_SUN_SENSORS@
 #define OBSW_ADD_SUS_BOARD_ASS                      @OBSW_ADD_SUS_BOARD_ASS@
 #define OBSW_ADD_ACS_BOARD                          @OBSW_ADD_ACS_BOARD@
 #define OBSW_ADD_ACS_CTRL                           1
 #define OBSW_ADD_GPS_CTRL                           @OBSW_ADD_GPS_CTRL@
+#define OBSW_ADD_TCS_CTRL                           @OBSW_ADD_TCS_CTRL@
 #define OBSW_ADD_RW                                 @OBSW_ADD_RW@
 #define OBSW_ADD_RTD_DEVICES                        @OBSW_ADD_RTD_DEVICES@
+#define OBSW_ADD_SA_DEPL                            @OBSW_ADD_SA_DEPL@
+#define OBSW_ADD_SCEX_DEVICE                        @OBSW_ADD_SCEX_DEVICE@
+#define OBSW_ADD_HEATERS                            @OBSW_ADD_HEATERS@
 #define OBSW_ADD_TMP_DEVICES                        @OBSW_ADD_TMP_DEVICES@
 #define OBSW_ADD_RAD_SENSORS                        @OBSW_ADD_RAD_SENSORS@
 #define OBSW_ADD_PL_PCDU                            @OBSW_ADD_PL_PCDU@
 #define OBSW_ADD_SYRLINKS                           @OBSW_ADD_SYRLINKS@
+#define OBSW_ADD_CCSDS_IP_CORES                     @OBSW_ADD_CCSDS_IP_CORES@
+// Set to 1 if all telemetry should be sent to the PTME IP Core
+#define OBSW_TM_TO_PTME                             @OBSW_TM_TO_PTME@
+// Set to 1 if telecommands are received via the PDEC IP Core
+#define OBSW_TC_FROM_PDEC                           @OBSW_TC_FROM_PDEC@
 #define OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT       0
-#define OBSW_MPSOC_JTAG_BOOT                        0
+
+// Configuration parameter which causes the core controller to try to keep at least one SD card
+// working
+#define OBSW_SD_CARD_MUST_BE_ON                     1
+#define OBSW_ENABLE_TIMERS                          1
 
 // This is a really tricky switch.. It initializes the PCDU switches to their default states
 // at powerup. I think it would be better
@@ -54,11 +60,12 @@
 /*******************************************************************/
 
 // Can be used to switch device to NORMAL mode immediately
-#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    1
+#define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    0
 #define OBSW_PRINT_MISSED_DEADLINES                 1
 
+#define OBSW_MPSOC_JTAG_BOOT                        0
 #define OBSW_STAR_TRACKER_GROUND_CONFIG             1
-#define OBSW_SYRLINKS_SIMULATED                     1
+#define OBSW_SYRLINKS_SIMULATED                     @OBSW_SYRLINKS_SIMULATED@
 #define OBSW_ADD_TEST_CODE                          0
 #define OBSW_ADD_TEST_TASK                          0
 #define OBSW_ADD_TEST_PST                           0

bsp_q7s/boardconfig/busConf.h

@@ -3,23 +3,25 @@
 
 namespace q7s {
 
-static constexpr char SPI_DEFAULT_DEV[] = "/dev/spi-main";
+static constexpr char SPI_DEFAULT_DEV[] = "/dev/spi_main";
 static constexpr uint32_t SPI_MAIN_BUS_LOCK_TIMEOUT = 50;
 
-static constexpr char SPI_RW_DEV[] = "/dev/spi-rw";
+static constexpr char SPI_RW_DEV[] = "/dev/spi_rw";
 
-static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c-eive";
+static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c_eive";
 
 static constexpr char UART_GNSS_DEV[] = "/dev/gps0";
-static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul-plmpsoc";
+static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul_plmpsoc";
-static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ul-plsv";
+static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ul_plsv";
-static constexpr char UART_SYRLINKS_DEV[] = "/dev/ul-syrlinks";
+static constexpr char UART_SYRLINKS_DEV[] = "/dev/ul_syrlinks";
-static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ul-str";
+static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ul_str";
+static constexpr char UART_SCEX_DEV[] = "/dev/scex";
 
-static constexpr char UIO_PDEC_REGISTERS[] = "/dev/uio0";
+static constexpr char UIO_PDEC_REGISTERS[] = "/dev/uio_pdec_regs";
-static constexpr char UIO_PTME[] = "/dev/uio1";
+static constexpr char UIO_PTME[] = "/dev/uio_ptme";
-static constexpr char UIO_PDEC_CONFIG_MEMORY[] = "/dev/uio2";
+static constexpr char UIO_PDEC_CONFIG_MEMORY[] = "/dev/uio_pdec_cfg_mem";
-static constexpr char UIO_PDEC_RAM[] = "/dev/uio3";
+static constexpr char UIO_PDEC_RAM[] = "/dev/uio_pdec_ram";
+static constexpr char UIO_PDEC_IRQ[] = "/dev/uio_pdec_irq";
 static constexpr int MAP_ID_PTME_CONFIG = 3;
 
 namespace uiomapids {

bsp_q7s/boardconfig/q7sConfig.h.in

@@ -16,16 +16,6 @@
 /** Other flags                                                    */
 /*******************************************************************/
 
-#define Q7S_SD_NONE                                 0
-#define Q7S_SD_COLD_REDUNDANT                       1
-#define Q7S_SD_HOT_REDUNDANT                        2
-// The OBSW will perform different actions to set up the SD cards depending on the flag set here
-// Set to Q7S_SD_NONE: Don't do anything
-// Set to Q7S_COLD_REDUNDANT: On startup, get the prefered SD card, turn it on and mount it, and 
-//     turn off the second SD card if it is on
-// Set to Q7S_HOT_REDUNDANT: On startup, turn on both SD cards and mount them  
-#define Q7S_SD_CARD_CONFIG                          Q7S_SD_COLD_REDUNDANT
-
 // Probably better if this is disabled for mission code. Convenient for development
 #define Q7S_CHECK_FOR_ALREADY_RUNNING_IMG           1
 

bsp_q7s/boardtest/Q7STestTask.cpp

@@ -1,10 +1,10 @@
 #include "Q7STestTask.h"
 
 #include <bsp_q7s/core/CoreController.h>
-#include <bsp_q7s/memory/FileSystemHandler.h>
 #include <bsp_q7s/xadc/Xadc.h>
 #include <fsfw/globalfunctions/arrayprinter.h>
 #include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw_hal/host/HostFilesystem.h>
 #include <gps.h>
 #include <libgpsmm.h>
 #include <param/param_string.h>
@@ -17,13 +17,17 @@
 #include <iostream>
 #include <nlohmann/json.hpp>
 
-#include "bsp_q7s/memory/SdCardManager.h"
+#include "OBSWConfig.h"
+#include "bsp_q7s/fs/SdCardManager.h"
+#include "bsp_q7s/fs/helpers.h"
 #include "bsp_q7s/memory/scratchApi.h"
 #include "fsfw/tasks/TaskFactory.h"
 #include "fsfw/timemanager/Stopwatch.h"
 #include "p60pdu.h"
 #include "test/DummyParameter.h"
 
+using namespace returnvalue;
+
 Q7STestTask::Q7STestTask(object_id_t objectId) : TestTask(objectId) {
   doTestSdCard = false;
   doTestScratchApi = false;
@@ -71,8 +75,10 @@ ReturnValue_t Q7STestTask::performOneShotAction() {
   if (doTestProtHandler) {
     testProtHandler();
   }
-  FsOpCodes opCode = FsOpCodes::APPEND_TO_FILE;
+  if (DO_TEST_FS_HANDLER) {
+    FsOpCodes opCode = FsOpCodes::CREATE_EMPTY_FILE_IN_TMP;
     testFileSystemHandlerDirect(opCode);
+  }
   return TestTask::performOneShotAction();
 }
 
@@ -366,145 +372,23 @@ void Q7STestTask::testGpsDaemonSocket() {
 }
 
 void Q7STestTask::testFileSystemHandlerDirect(FsOpCodes opCode) {
-  auto fsHandler = ObjectManager::instance()->get<FileSystemHandler>(objects::FILE_SYSTEM_HANDLER);
+  HostFilesystem hostFs;
-  if (fsHandler == nullptr) {
+  auto* sdcMan = SdCardManager::instance();
-    sif::warning << "Q7STestTask::testFileSystemHandlerDirect: No FS handler running.."
+  std::string mountPrefix = sdcMan->getCurrentMountPrefix();
-                 << std::endl;
+  sif::info << "Current mount prefix: " << mountPrefix << std::endl;
+  auto prefixedPath = fshelpers::getPrefixedPath(*sdcMan, "conf/test.txt");
+  sif::info << "Prefixed path: " << prefixedPath << std::endl;
+  if (opCode == FsOpCodes::CREATE_EMPTY_FILE_IN_TMP) {
+    FilesystemParams params("/tmp/hello.txt");
+    auto res = hostFs.createFile(params);
+    if (res != OK) {
+      sif::warning << "Creating empty file in /tmp failed" << std::endl;
     }
-  FileSystemHandler::FsCommandCfg cfg = {};
+    bool fileExists = std::filesystem::exists("/tmp/hello.txt");
-  ReturnValue_t result = returnvalue::OK;
+    if (not fileExists) {
-
+      sif::warning << "File was not created!" << std::endl;
-  // Lambda for common code
-  auto createNonEmptyTmpDir = [&]() {
-    if (not std::filesystem::exists("/tmp/test")) {
-      result = fsHandler->createDirectory("/tmp", "test", false, &cfg);
-      if (result != returnvalue::OK) {
-        return result;
-      }
-    }
-    // Creating sample files
-    sif::info << "Creating sample files in directory" << std::endl;
-    result = fsHandler->createFile("/tmp/test", "test1.txt", nullptr, 0, &cfg);
-    if (result != returnvalue::OK) {
-      return result;
-    }
-    result = fsHandler->createFile("/tmp/test", "test2.txt", nullptr, 0, &cfg);
-    if (result != returnvalue::OK) {
-      return result;
-    }
-    return result;
-  };
-
-  switch (opCode) {
-    case (FsOpCodes::CREATE_EMPTY_FILE_IN_TMP): {
-      // No mount prefix, cause file is created in tmp
-      cfg.useMountPrefix = false;
-      sif::info << "Creating empty file in /tmp folder" << std::endl;
-      // Do not delete file, user can check existence in shell
-      fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
-      break;
-    }
-    case (FsOpCodes::REMOVE_TMP_FILE): {
-      sif::info << "Deleting /tmp/test.txt sample file" << std::endl;
-      // No mount prefix, cause file is created in tmp
-      cfg.useMountPrefix = false;
-      if (not std::filesystem::exists("/tmp/test.txt")) {
-        // Creating sample file
-        sif::info << "Creating sample file /tmp/test.txt to delete" << std::endl;
-        fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
-      }
-      result = fsHandler->removeFile("/tmp", "test.txt", &cfg);
-      if (result == returnvalue::OK) {
-        sif::info << "File removed successfully" << std::endl;
-      } else {
-        sif::warning << "File removal failed!" << std::endl;
-      }
-      break;
-    }
-    case (FsOpCodes::CREATE_DIR_IN_TMP): {
-      // No mount prefix, cause file is created in tmp
-      cfg.useMountPrefix = false;
-      sif::info << "Creating empty file in /tmp folder" << std::endl;
-      // Do not delete file, user can check existence in shell
-      ReturnValue_t result = fsHandler->createDirectory("/tmp/", "test", false, &cfg);
-      if (result == returnvalue::OK) {
-        sif::info << "Directory created successfully" << std::endl;
-      } else {
-        sif::warning << "Directory creation failed!" << std::endl;
-      }
-      break;
-    }
-    case (FsOpCodes::REMOVE_EMPTY_DIR_IN_TMP): {
-      // No mount prefix, cause file is created in tmp
-      cfg.useMountPrefix = false;
-      if (not std::filesystem::exists("/tmp/test")) {
-        result = fsHandler->createDirectory("/tmp", "test", false, &cfg);
-      } else {
-        // Delete any leftover files to regular dir removal works
-        std::remove("/tmp/test/*");
-      }
-      result = fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
-      if (result == returnvalue::OK) {
-        sif::info << "Directory removed successfully" << std::endl;
-      } else {
-        sif::warning << "Directory removal failed!" << std::endl;
-      }
-      break;
-    }
-    case (FsOpCodes::REMOVE_FILLED_DIR_IN_TMP): {
-      result = createNonEmptyTmpDir();
-      if (result != returnvalue::OK) {
-        return;
-      }
-      result = fsHandler->removeDirectory("/tmp/", "test", true, &cfg);
-      if (result == returnvalue::OK) {
-        sif::info << "Directory removed recursively successfully" << std::endl;
-      } else {
-        sif::warning << "Recursive directory removal failed!" << std::endl;
-      }
-      break;
-    }
-    case (FsOpCodes::ATTEMPT_DIR_REMOVAL_NON_EMPTY): {
-      result = createNonEmptyTmpDir();
-      if (result != returnvalue::OK) {
-        return;
-      }
-      result = fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
-      if (result != returnvalue::OK) {
-        sif::info << "Directory removal attempt failed as expected" << std::endl;
-      } else {
-        sif::warning << "Directory removal worked when it should not have!" << std::endl;
-      }
-      break;
-    }
-    case (FsOpCodes::RENAME_FILE): {
-      // No mount prefix, cause file is created in tmp
-      cfg.useMountPrefix = false;
-      if (std::filesystem::exists("/tmp/test.txt")) {
-        fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
-      }
-      sif::info << "Creating empty file /tmp/test.txt and rename to /tmp/test2.txt" << std::endl;
-      // Do not delete file, user can check existence in shell
-      fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
-      fsHandler->renameFile("/tmp/", "test.txt", "test2.txt", &cfg);
-      break;
-    }
-    case (FsOpCodes::APPEND_TO_FILE): {
-      // No mount prefix, cause file is created in tmp
-      cfg.useMountPrefix = false;
-      if (std::filesystem::exists("/tmp/test.txt")) {
-        fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
-      }
-      if (std::filesystem::exists("/tmp/test.txt")) {
-        fsHandler->removeDirectory("/tmp/", "test", false, &cfg);
-      }
-      sif::info << "Creating empty file /tmp/test.txt and adding content" << std::endl;
-      std::string content = "Hello World\n";
-      // Do not delete file, user can check existence in shell
-      fsHandler->createFile("/tmp/", "test.txt", nullptr, 0, &cfg);
-      fsHandler->appendToFile("/tmp/", "test.txt", reinterpret_cast<const uint8_t*>(content.data()),
-                              content.size(), 0, &cfg);
     }
+    hostFs.removeFile("/tmp/hello.txt");
   }
 }
 

bsp_q7s/boardtest/Q7STestTask.h

@@ -18,6 +18,7 @@ class Q7STestTask : public TestTask {
   bool doTestScratchApi = false;
   static constexpr bool DO_TEST_GOMSPACE_API = false;
   static constexpr bool DO_TEST_GOMSPACE_GET_CONFIG = false;
+  static constexpr bool DO_TEST_FS_HANDLER = false;
   bool doTestGpsShm = false;
   bool doTestGpsSocket = false;
   bool doTestProtHandler = false;

bsp_q7s/callbacks/rwSpiCallback.cpp

@@ -41,19 +41,19 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
   uint8_t writeSize = 0;
 
   gpioId_t gpioId = cookie->getChipSelectPin();
-  GpioIF* gpioIF = comIf->getGpioInterface();
+  GpioIF& gpioIF = comIf->getGpioInterface();
   MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
   uint32_t timeoutMs = 0;
   MutexIF* mutex = comIf->getCsMutex();
   cookie->getMutexParams(timeoutType, timeoutMs);
-  if (mutex == nullptr or gpioIF == nullptr) {
+  if (mutex == nullptr) {
     sif::debug << "rwSpiCallback::spiCallback: Mutex or GPIO interface invalid" << std::endl;
     return returnvalue::FAILED;
   }
 
   int fileDescriptor = 0;
   const std::string& dev = comIf->getSpiDev();
-  result = openSpi(dev, O_RDWR, gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
+  result = openSpi(dev, O_RDWR, &gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -75,7 +75,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
 
   if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
     sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
-    closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+    closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
     return RwHandler::SPI_WRITE_FAILURE;
   }
 
@@ -100,7 +100,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
     }
     if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
       sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
-      closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+      closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
       return RwHandler::SPI_WRITE_FAILURE;
     }
     idx++;
@@ -112,14 +112,14 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
 
   if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
     sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
-    closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+    closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
     return RwHandler::SPI_WRITE_FAILURE;
   }
 
   uint8_t* rxBuf = nullptr;
   result = comIf->getReadBuffer(cookie->getSpiAddress(), &rxBuf);
   if (result != returnvalue::OK) {
-    closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+    closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
     return result;
   }
 
@@ -127,9 +127,9 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
 
   // There must be a delay of at least 20 ms after sending the command.
   // Delay for 70 ms here and release the SPI bus for that duration.
-  closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+  closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
   usleep(RwDefinitions::SPI_REPLY_DELAY);
-  result = openSpi(dev, O_RDWR, gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
+  result = openSpi(dev, O_RDWR, &gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
   if (result != returnvalue::OK) {
     return result;
   }
@@ -142,13 +142,13 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
   for (int idx = 0; idx < 10; idx++) {
     if (read(fileDescriptor, &byteRead, 1) != 1) {
       sif::error << "rwSpiCallback::spiCallback: Read failed" << std::endl;
-      closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+      closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
       return RwHandler::SPI_READ_FAILURE;
     }
     if (idx == 0) {
       if (byteRead != FLAG_BYTE) {
         sif::error << "Invalid data, expected start marker" << std::endl;
-        closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+        closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
         return RwHandler::NO_START_MARKER;
       }
     }
@@ -159,7 +159,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
 
     if (idx == 9) {
       sif::error << "rwSpiCallback::spiCallback: Empty frame timeout" << std::endl;
-      closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+      closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
       return RwHandler::NO_REPLY;
     }
   }
@@ -199,7 +199,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
         continue;
       } else {
         sif::error << "rwSpiCallback::spiCallback: Invalid substitute" << std::endl;
-        closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+        closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
         result = RwHandler::INVALID_SUBSTITUTE;
         break;
       }
@@ -233,7 +233,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
 
   cookie->setTransferSize(decodedFrameLen);
 
-  closeSpi(fileDescriptor, gpioId, gpioIF, mutex);
+  closeSpi(fileDescriptor, gpioId, &gpioIF, mutex);
 
   return result;
 }

bsp_q7s/core/CoreController.cpp

@@ -1,9 +1,10 @@
 #include "CoreController.h"
 
 #include <fsfw/events/EventManager.h>
+#include <fsfw/filesystem/HasFileSystemIF.h>
 #include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/tasks/TaskFactory.h>
 
-#include "OBSWConfig.h"
 #include "OBSWVersion.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/timemanager/Stopwatch.h"
@@ -20,19 +21,17 @@
 #include <algorithm>
 #include <filesystem>
 
-#include "bsp_q7s/memory/SdCardManager.h"
+#include "bsp_q7s/fs/SdCardManager.h"
 #include "bsp_q7s/memory/scratchApi.h"
 #include "bsp_q7s/xadc/Xadc.h"
+#include "eive/definitions.h"
 #include "linux/utility/utility.h"
 
 xsc::Chip CoreController::CURRENT_CHIP = xsc::Chip::NO_CHIP;
 xsc::Copy CoreController::CURRENT_COPY = xsc::Copy::NO_COPY;
 
 CoreController::CoreController(object_id_t objectId)
-    : ExtendedControllerBase(objectId, objects::NO_OBJECT, 5),
+    : ExtendedControllerBase(objectId, 5), opDivider5(5), opDivider10(10), hkSet(this) {
-      opDivider5(5),
-      opDivider10(10),
-      hkSet(this) {
   ReturnValue_t result = returnvalue::OK;
   try {
     result = initWatchdogFifo();
@@ -47,7 +46,6 @@ CoreController::CoreController(object_id_t objectId)
     if (not BLOCKING_SD_INIT) {
       sdcMan->setBlocking(false);
     }
-    sdStateMachine();
 
     result = initBootCopy();
     if (result != returnvalue::OK) {
@@ -60,6 +58,8 @@ CoreController::CoreController(object_id_t objectId)
   eventQueue = QueueFactory::instance()->createMessageQueue(5, EventMessage::MAX_MESSAGE_SIZE);
 }
 
+CoreController::~CoreController() {}
+
 ReturnValue_t CoreController::handleCommandMessage(CommandMessage *message) {
   return ExtendedControllerBase::handleCommandMessage(message);
 }
@@ -79,6 +79,12 @@ void CoreController::performControlOperation() {
   sdStateMachine();
   performMountedSdCardOperations();
   if (sdCardCheckCd.hasTimedOut()) {
+    if (shortSdCardCdCounter < 2) {
+      shortSdCardCdCounter++;
+    }
+    if (shortSdCardCdCounter == 2) {
+      sdCardCheckCd.setTimeout(DEFAULT_SD_CARD_CHECK_TIMEOUT);
+    }
     performSdCardCheck();
     sdCardCheckCd.resetTimer();
   }
@@ -139,8 +145,18 @@ ReturnValue_t CoreController::initialize() {
 
 ReturnValue_t CoreController::initializeAfterTaskCreation() {
   ReturnValue_t result = returnvalue::OK;
-  sdInfo.pref = sdcMan->getPreferredSdCard();
+  auto sdCard = sdcMan->getPreferredSdCard();
-  sdcMan->setActiveSdCard(sdInfo.pref);
+  if (not sdCard) {
+    return returnvalue::FAILED;
+  }
+  sdInfo.active = sdCard.value();
+  if (sdInfo.active == sd::SdCard::NONE) {
+    sif::error << "CoreController::initializeAfterTaskCreation: "
+                  "Issues getting preferred SD card, setting to 0"
+               << std::endl;
+    sdInfo.active = sd::SdCard::SLOT_0;
+  }
+  sdcMan->setActiveSdCard(sdInfo.active);
   currMntPrefix = sdcMan->getCurrentMountPrefix();
   if (BLOCKING_SD_INIT) {
     ReturnValue_t result = initSdCardBlocking();
@@ -198,6 +214,47 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
       }
       return HasActionsIF::EXECUTION_FINISHED;
     }
+    case (OBSW_UPDATE_FROM_SD_0): {
+      return executeSwUpdate(SwUpdateSources::SD_0, data, size);
+    }
+    case (OBSW_UPDATE_FROM_SD_1): {
+      return executeSwUpdate(SwUpdateSources::SD_1, data, size);
+    }
+    case (OBSW_UPDATE_FROM_TMP): {
+      return executeSwUpdate(SwUpdateSources::TMP_DIR, data, size);
+    }
+    case (SWITCH_TO_SD_0): {
+      if (not startSdStateMachine(sd::SdCard::SLOT_0, SdCfgMode::COLD_REDUNDANT, commandedBy,
+                                  actionId)) {
+        return HasActionsIF::IS_BUSY;
+      }
+      // Completion will be reported by SD card state machine
+      return returnvalue::OK;
+    }
+    case (SWITCH_TO_SD_1): {
+      if (not startSdStateMachine(sd::SdCard::SLOT_1, SdCfgMode::COLD_REDUNDANT, commandedBy,
+                                  actionId)) {
+        return HasActionsIF::IS_BUSY;
+      }
+      // Completion will be reported by SD card state machine
+      return returnvalue::OK;
+    }
+    case (SWITCH_TO_BOTH_SD_CARDS): {
+      // An active SD still needs to be specified because the system needs to know which SD
+      // card to use for regular operations like telemetry storage.
+      if (size != 1) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      if (data[0] != 0 and data[0] != 1) {
+        return HasActionsIF::INVALID_PARAMETERS;
+      }
+      auto active = static_cast<sd::SdCard>(data[0]);
+      if (not startSdStateMachine(active, SdCfgMode::HOT_REDUNDANT, commandedBy, actionId)) {
+        return HasActionsIF::IS_BUSY;
+      }
+      // Completion will be reported by SD card state machine
+      return returnvalue::OK;
+    }
     case (SWITCH_IMG_LOCK): {
       if (size != 3) {
         return HasActionsIF::INVALID_PARAMETERS;
@@ -245,60 +302,59 @@ ReturnValue_t CoreController::initSdCardBlocking() {
   if (result != returnvalue::OK) {
     sif::warning << "CoreController::initialize: Updating SD card state file failed" << std::endl;
   }
-#if Q7S_SD_CARD_CONFIG == Q7S_SD_NONE
+  if (sdInfo.cfgMode == SdCfgMode::PASSIVE) {
     sif::info << "No SD card initialization will be performed" << std::endl;
     return returnvalue::OK;
-#else
+  }
 
   result = sdcMan->getSdCardsStatus(sdInfo.currentState);
   if (result != returnvalue::OK) {
     sif::warning << "Getting SD card activity status failed" << std::endl;
   }
 
-#if Q7S_SD_CARD_CONFIG == Q7S_SD_COLD_REDUNDANT
+  if (sdInfo.cfgMode == SdCfgMode::COLD_REDUNDANT) {
     updateSdInfoOther();
     sif::info << "Cold redundant SD card configuration, preferred SD card: "
-            << static_cast<int>(sdInfo.pref) << std::endl;
+              << static_cast<int>(sdInfo.active) << std::endl;
     result = sdColdRedundantBlockingInit();
     // Update status file
     sdcMan->updateSdCardStateFile();
     return result;
-#elif Q7S_SD_CARD_CONFIG == Q7S_SD_HOT_REDUNDANT
+  }
+  if (sdInfo.cfgMode == SdCfgMode::HOT_REDUNDANT) {
     sif::info << "Hot redundant SD card configuration" << std::endl;
     sdCardSetup(sd::SdCard::SLOT_0, sd::SdState::MOUNTED, "0", false);
     sdCardSetup(sd::SdCard::SLOT_1, sd::SdState::MOUNTED, "1", false);
     // Update status file
     sdcMan->updateSdCardStateFile();
+  }
   return returnvalue::OK;
-#endif
-
-#endif /* Q7S_SD_CARD_CONFIG != Q7S_SD_NONE */
 }
 
 ReturnValue_t CoreController::sdStateMachine() {
   ReturnValue_t result = returnvalue::OK;
   SdCardManager::Operations operation;
 
-  if (sdInfo.state == SdStates::IDLE) {
+  if (sdFsmState == SdStates::IDLE) {
     // Nothing to do
     return result;
   }
 
-  if (sdInfo.state == SdStates::START) {
+  if (sdFsmState == SdStates::START) {
     // Init will be performed by separate function
     if (BLOCKING_SD_INIT) {
-      sdInfo.state = SdStates::IDLE;
+      sdFsmState = SdStates::IDLE;
       sdInfo.initFinished = true;
       return result;
     } else {
       // Still update SD state file
-#if Q7S_SD_CARD_CONFIG == Q7S_SD_NONE
+      if (sdInfo.cfgMode == SdCfgMode::PASSIVE) {
-      sdInfo.state = SdStates::UPDATE_INFO;
+        sdFsmState = SdStates::UPDATE_INFO;
-#else
+      } else {
         sdInfo.cycleCount = 0;
         sdInfo.commandExecuted = false;
-      sdInfo.state = SdStates::GET_INFO;
+        sdFsmState = SdStates::GET_INFO;
-#endif
+      }
     }
   }
 
@@ -308,7 +364,7 @@ ReturnValue_t CoreController::sdStateMachine() {
                                    std::string opPrintout) {
     SdCardManager::OpStatus status = sdcMan->checkCurrentOp(operation);
     if (status == SdCardManager::OpStatus::SUCCESS) {
-      sdInfo.state = newStateOnSuccess;
+      sdFsmState = newStateOnSuccess;
       sdInfo.commandExecuted = false;
       sdInfo.cycleCount = 0;
       return true;
@@ -320,9 +376,9 @@ ReturnValue_t CoreController::sdStateMachine() {
     return false;
   };
 
-  if (sdInfo.state == SdStates::GET_INFO) {
+  if (sdFsmState == SdStates::GET_INFO) {
     if (not sdInfo.commandExecuted) {
-      // Create update status file
+      // Create updated status file
       result = sdcMan->updateSdCardStateFile();
       if (result != returnvalue::OK) {
         sif::warning << "CoreController::initialize: Updating SD card state file failed"
@@ -334,88 +390,91 @@ ReturnValue_t CoreController::sdStateMachine() {
     }
   }
 
-  if (sdInfo.state == SdStates::SET_STATE_SELF) {
+  if (sdFsmState == SdStates::SET_STATE_SELF) {
     if (not sdInfo.commandExecuted) {
       result = sdcMan->getSdCardsStatus(sdInfo.currentState);
-      sdInfo.pref = sdcMan->getPreferredSdCard();
       updateSdInfoOther();
-      if (sdInfo.pref != sd::SdCard::SLOT_0 and sdInfo.pref != sd::SdCard::SLOT_1) {
+      if (sdInfo.active != sd::SdCard::SLOT_0 and sdInfo.active != sd::SdCard::SLOT_1) {
         sif::warning << "Preferred SD card invalid. Setting to card 0.." << std::endl;
-        sdInfo.pref = sd::SdCard::SLOT_0;
+        sdInfo.active = sd::SdCard::SLOT_0;
       }
       if (result != returnvalue::OK) {
         sif::warning << "Getting SD card activity status failed" << std::endl;
       }
-#if Q7S_SD_CARD_CONFIG == Q7S_SD_COLD_REDUNDANT
+      if (sdInfo.cfgMode == SdCfgMode::COLD_REDUNDANT) {
-      sif::info << "Cold redundant SD card configuration, preferred SD card: "
+        sif::info << "Cold redundant SD card configuration, target SD card: "
-                << static_cast<int>(sdInfo.pref) << std::endl;
+                  << static_cast<int>(sdInfo.active) << std::endl;
-#endif
+      }
-      if (sdInfo.prefState == sd::SdState::MOUNTED) {
+      if (sdInfo.activeState == sd::SdState::MOUNTED) {
 #if OBSW_VERBOSE_LEVEL >= 1
         std::string mountString;
-        if (sdInfo.pref == sd::SdCard::SLOT_0) {
+        if (sdInfo.active == sd::SdCard::SLOT_0) {
-          mountString = SdCardManager::SD_0_MOUNT_POINT;
+          mountString = config::SD_0_MOUNT_POINT;
         } else {
-          mountString = SdCardManager::SD_1_MOUNT_POINT;
+          mountString = config::SD_1_MOUNT_POINT;
         }
-        sif::info << "SD card " << sdInfo.prefChar << " already on and mounted at " << mountString
+        sif::info << "SD card " << sdInfo.activeChar << " already on and mounted at " << mountString
                   << std::endl;
 #endif
-        sdInfo.state = SdStates::DETERMINE_OTHER;
+        sdcMan->setActiveSdCard(sdInfo.active);
-      } else if (sdInfo.prefState == sd::SdState::OFF) {
+        currMntPrefix = sdcMan->getCurrentMountPrefix();
-        sdCardSetup(sdInfo.pref, sd::SdState::ON, sdInfo.prefChar, false);
+        sdFsmState = SdStates::DETERMINE_OTHER;
+      } else if (sdInfo.activeState == sd::SdState::OFF) {
+        sdCardSetup(sdInfo.active, sd::SdState::ON, sdInfo.activeChar, false);
         sdInfo.commandExecuted = true;
-      } else if (sdInfo.prefState == sd::SdState::ON) {
+      } else if (sdInfo.activeState == sd::SdState::ON) {
-        sdInfo.state = SdStates::MOUNT_SELF;
+        sdFsmState = SdStates::MOUNT_SELF;
       }
     } else {
       if (nonBlockingOpChecking(SdStates::MOUNT_SELF, 10, "Setting SDC state")) {
-        sdInfo.prefState = sd::SdState::ON;
+        sdInfo.activeState = sd::SdState::ON;
-        currentStateSetter(sdInfo.pref, sd::SdState::ON);
+        currentStateSetter(sdInfo.active, sd::SdState::ON);
       }
     }
   }
 
-  if (sdInfo.state == SdStates::MOUNT_SELF) {
+  if (sdFsmState == SdStates::MOUNT_SELF) {
     if (not sdInfo.commandExecuted) {
-      result = sdCardSetup(sdInfo.pref, sd::SdState::MOUNTED, sdInfo.prefChar);
+      result = sdCardSetup(sdInfo.active, sd::SdState::MOUNTED, sdInfo.activeChar);
       sdInfo.commandExecuted = true;
     } else {
       if (nonBlockingOpChecking(SdStates::DETERMINE_OTHER, 5, "Mounting SD card")) {
-        sdInfo.prefState = sd::SdState::MOUNTED;
+        sdcMan->setActiveSdCard(sdInfo.active);
-        currentStateSetter(sdInfo.pref, sd::SdState::MOUNTED);
+        currMntPrefix = sdcMan->getCurrentMountPrefix();
+        sdInfo.activeState = sd::SdState::MOUNTED;
+        currentStateSetter(sdInfo.active, sd::SdState::MOUNTED);
       }
     }
   }
 
-  if (sdInfo.state == SdStates::DETERMINE_OTHER) {
+  if (sdFsmState == SdStates::DETERMINE_OTHER) {
     // Determine whether any additional operations have to be done for the other SD card
     // 1. Cold redundant case: Other SD card needs to be unmounted and switched off
     // 2. Hot redundant case: Other SD card needs to be mounted and switched on
-#if Q7S_SD_CARD_CONFIG == Q7S_SD_COLD_REDUNDANT
+    if (sdInfo.cfgMode == SdCfgMode::COLD_REDUNDANT) {
       if (sdInfo.otherState == sd::SdState::ON) {
-      sdInfo.state = SdStates::SET_STATE_OTHER;
+        sdFsmState = SdStates::SET_STATE_OTHER;
       } else if (sdInfo.otherState == sd::SdState::MOUNTED) {
-      sdInfo.state = SdStates::MOUNT_UNMOUNT_OTHER;
+        sdFsmState = SdStates::MOUNT_UNMOUNT_OTHER;
       } else {
         // Is already off, update info, but with a small delay
-      sdInfo.state = SdStates::SKIP_CYCLE_BEFORE_INFO_UPDATE;
+        sdFsmState = SdStates::SKIP_CYCLE_BEFORE_INFO_UPDATE;
       }
-#elif Q7S_SD_CARD_CONFIG == Q7S_SD_HOT_REDUNDANT
+    } else if (sdInfo.cfgMode == SdCfgMode::HOT_REDUNDANT) {
       if (sdInfo.otherState == sd::SdState::OFF) {
-      sdInfo.state = SdStates::SET_STATE_OTHER;
+        sdFsmState = SdStates::SET_STATE_OTHER;
       } else if (sdInfo.otherState == sd::SdState::ON) {
-      sdInfo.state = SdStates::MOUNT_UNMOUNT_OTHER;
+        sdFsmState = SdStates::MOUNT_UNMOUNT_OTHER;
       } else {
         // Is already on and mounted, update info
-      sdInfo.state = SdStates::SKIP_CYCLE_BEFORE_INFO_UPDATE;
+        sdFsmState = SdStates::SKIP_CYCLE_BEFORE_INFO_UPDATE;
+      }
     }
-#endif
   }
 
-  if (sdInfo.state == SdStates::SET_STATE_OTHER) {
+  if (sdFsmState == SdStates::SET_STATE_OTHER) {
     // Set state of other SD card to ON or OFF, depending on redundancy mode
-#if Q7S_SD_CARD_CONFIG == Q7S_SD_COLD_REDUNDANT
+    if (sdInfo.cfgMode == SdCfgMode::COLD_REDUNDANT) {
       if (not sdInfo.commandExecuted) {
         result = sdCardSetup(sdInfo.other, sd::SdState::OFF, sdInfo.otherChar, false);
         sdInfo.commandExecuted = true;
@@ -426,22 +485,23 @@ ReturnValue_t CoreController::sdStateMachine() {
           currentStateSetter(sdInfo.other, sd::SdState::OFF);
         }
       }
-#elif Q7S_SD_CARD_CONFIG == Q7S_SD_HOT_REDUNDANT
+    } else if (sdInfo.cfgMode == SdCfgMode::HOT_REDUNDANT) {
       if (not sdInfo.commandExecuted) {
         result = sdCardSetup(sdInfo.other, sd::SdState::ON, sdInfo.otherChar, false);
         sdInfo.commandExecuted = true;
       } else {
-      if (nonBlockingOpChecking(SdStates::MOUNT_UNMOUNT_OTHER, 10, "Switching on other SD card")) {
+        if (nonBlockingOpChecking(SdStates::MOUNT_UNMOUNT_OTHER, 10,
+                                  "Switching on other SD card")) {
           sdInfo.otherState = sd::SdState::ON;
           currentStateSetter(sdInfo.other, sd::SdState::ON);
         }
       }
-#endif
+    }
   }
 
-  if (sdInfo.state == SdStates::MOUNT_UNMOUNT_OTHER) {
+  if (sdFsmState == SdStates::MOUNT_UNMOUNT_OTHER) {
     // Mount or unmount other SD card, depending on redundancy mode
-#if Q7S_SD_CARD_CONFIG == Q7S_SD_COLD_REDUNDANT
+    if (sdInfo.cfgMode == SdCfgMode::COLD_REDUNDANT) {
       if (not sdInfo.commandExecuted) {
         result = sdCardSetup(sdInfo.other, sd::SdState::ON, sdInfo.otherChar);
         sdInfo.commandExecuted = true;
@@ -451,7 +511,7 @@ ReturnValue_t CoreController::sdStateMachine() {
           currentStateSetter(sdInfo.other, sd::SdState::ON);
         }
       }
-#elif Q7S_SD_CARD_CONFIG == Q7S_SD_HOT_REDUNDANT
+    } else if (sdInfo.cfgMode == SdCfgMode::HOT_REDUNDANT) {
       if (not sdInfo.commandExecuted) {
         result = sdCardSetup(sdInfo.other, sd::SdState::MOUNTED, sdInfo.otherChar);
         sdInfo.commandExecuted = true;
@@ -461,12 +521,12 @@ ReturnValue_t CoreController::sdStateMachine() {
           currentStateSetter(sdInfo.other, sd::SdState::MOUNTED);
         }
       }
-#endif
+    }
   }
 
-  if (sdInfo.state == SdStates::SKIP_CYCLE_BEFORE_INFO_UPDATE) {
+  if (sdFsmState == SdStates::SKIP_CYCLE_BEFORE_INFO_UPDATE) {
-    sdInfo.state = SdStates::UPDATE_INFO;
+    sdFsmState = SdStates::UPDATE_INFO;
-  } else if (sdInfo.state == SdStates::UPDATE_INFO) {
+  } else if (sdFsmState == SdStates::UPDATE_INFO) {
     // It is assumed that all tasks are running by the point this section is reached.
     // Therefore, perform this operation in blocking mode because it does not take long
     // and the ready state of the SD card is available sooner
@@ -477,10 +537,15 @@ ReturnValue_t CoreController::sdStateMachine() {
       sif::warning << "CoreController::initialize: Updating SD card state file failed" << std::endl;
     }
     sdInfo.commandExecuted = false;
-    sdInfo.state = SdStates::IDLE;
+    sdFsmState = SdStates::IDLE;
     sdInfo.cycleCount = 0;
     sdcMan->setBlocking(false);
     sdcMan->getSdCardsStatus(sdInfo.currentState);
+    if (sdCommandingInfo.cmdPending) {
+      sdCommandingInfo.cmdPending = false;
+      actionHelper.finish(true, sdCommandingInfo.commander, sdCommandingInfo.actionId,
+                          returnvalue::OK);
+    }
     if (not sdInfo.initFinished) {
       updateSdInfoOther();
       sdInfo.initFinished = true;
@@ -488,81 +553,10 @@ ReturnValue_t CoreController::sdStateMachine() {
     }
   }
 
-  if (sdInfo.state == SdStates::SET_STATE_FROM_COMMAND) {
-    if (not sdInfo.commandExecuted) {
-      executeNextExternalSdCommand();
-    } else {
-      checkExternalSdCommandStatus();
-    }
-  }
-
   sdInfo.cycleCount++;
   return returnvalue::OK;
 }
 
-void CoreController::executeNextExternalSdCommand() {
-  std::string sdChar;
-  sd::SdState currentStateOfCard = sd::SdState::OFF;
-  if (sdInfo.commandedCard == sd::SdCard::SLOT_0) {
-    sdChar = "0";
-    currentStateOfCard = sdInfo.currentState.first;
-  } else {
-    sdChar = "1";
-    currentStateOfCard = sdInfo.currentState.second;
-  }
-  if (currentStateOfCard == sd::SdState::OFF) {
-    if (sdInfo.commandedState == sd::SdState::ON) {
-      sdInfo.currentlyCommandedState = sdInfo.commandedState;
-    } else if (sdInfo.commandedState == sd::SdState::MOUNTED) {
-      sdInfo.currentlyCommandedState = sd::SdState::ON;
-    } else {
-      // SD card is already on target state
-      sdInfo.commandFinished = true;
-      sdInfo.state = SdStates::IDLE;
-    }
-  } else if (currentStateOfCard == sd::SdState::ON) {
-    if (sdInfo.commandedState == sd::SdState::OFF or
-        sdInfo.commandedState == sd::SdState::MOUNTED) {
-      sdInfo.currentlyCommandedState = sdInfo.commandedState;
-    } else {
-      // Already on target state
-      sdInfo.commandFinished = true;
-      sdInfo.state = SdStates::IDLE;
-    }
-  } else if (currentStateOfCard == sd::SdState::MOUNTED) {
-    if (sdInfo.commandedState == sd::SdState::ON) {
-      sdInfo.currentlyCommandedState = sdInfo.commandedState;
-    } else if (sdInfo.commandedState == sd::SdState::OFF) {
-      // This causes an unmount in sdCardSetup
-      sdInfo.currentlyCommandedState = sd::SdState::ON;
-    } else {
-      sdInfo.commandFinished = true;
-    }
-  }
-  sdCardSetup(sdInfo.commandedCard, sdInfo.commandedState, sdChar);
-  sdInfo.commandExecuted = true;
-}
-
-void CoreController::checkExternalSdCommandStatus() {
-  SdCardManager::Operations operation;
-  SdCardManager::OpStatus status = sdcMan->checkCurrentOp(operation);
-  if (status == SdCardManager::OpStatus::SUCCESS) {
-    if (sdInfo.currentlyCommandedState == sdInfo.commandedState) {
-      sdInfo.state = SdStates::SKIP_CYCLE_BEFORE_INFO_UPDATE;
-      sdInfo.commandFinished = true;
-    } else {
-      // stay on same state machine state because the target state was not reached yet.
-      sdInfo.cycleCount = 0;
-    }
-    currentStateSetter(sdInfo.commandedCard, sdInfo.currentlyCommandedState);
-    sdInfo.commandExecuted = false;
-  } else if (sdInfo.cycleCount > 4) {
-    sif::warning << "CoreController::sdStateMachine: Commanding SD state "
-                    "takes too long"
-                 << std::endl;
-  }
-}
-
 void CoreController::currentStateSetter(sd::SdCard sdCard, sd::SdState newState) {
   if (sdCard == sd::SdCard::SLOT_0) {
     sdInfo.currentState.first = newState;
@@ -576,9 +570,9 @@ ReturnValue_t CoreController::sdCardSetup(sd::SdCard sdCard, sd::SdState targetS
   std::string mountString;
   sdcMan->setPrintCommandOutput(printOutput);
   if (sdCard == sd::SdCard::SLOT_0) {
-    mountString = SdCardManager::SD_0_MOUNT_POINT;
+    mountString = config::SD_0_MOUNT_POINT;
   } else {
-    mountString = SdCardManager::SD_1_MOUNT_POINT;
+    mountString = config::SD_1_MOUNT_POINT;
   }
 
   sd::SdState state = sd::SdState::OFF;
@@ -634,12 +628,12 @@ ReturnValue_t CoreController::sdCardSetup(sd::SdCard sdCard, sd::SdState targetS
 ReturnValue_t CoreController::sdColdRedundantBlockingInit() {
   ReturnValue_t result = returnvalue::OK;
 
-  result = sdCardSetup(sdInfo.pref, sd::SdState::MOUNTED, sdInfo.prefChar);
+  result = sdCardSetup(sdInfo.active, sd::SdState::MOUNTED, sdInfo.activeChar);
   if (result != SdCardManager::ALREADY_MOUNTED and result != returnvalue::OK) {
     sif::warning << "Setting up preferred card " << sdInfo.otherChar
                  << " in cold redundant mode failed" << std::endl;
     // Try other SD card and mark set up operation as failed
-    sdCardSetup(sdInfo.pref, sd::SdState::MOUNTED, sdInfo.prefChar);
+    sdCardSetup(sdInfo.active, sd::SdState::MOUNTED, sdInfo.activeChar);
     result = returnvalue::FAILED;
   }
 
@@ -942,6 +936,9 @@ ReturnValue_t CoreController::actionReboot(const uint8_t *data, size_t size) {
 ReturnValue_t CoreController::gracefulShutdownTasks(xsc::Chip chip, xsc::Copy copy,
                                                     bool &protOpPerformed) {
   sdcMan->setBlocking(true);
+  sdcMan->markUnusable();
+  // Wait two seconds to ensure no one uses the SD cards
+  TaskFactory::delayTask(2000);
   // Attempt graceful shutdown by unmounting and switching off SD cards
   sdcMan->switchOffSdCard(sd::SdCard::SLOT_0);
   sdcMan->switchOffSdCard(sd::SdCard::SLOT_1);
@@ -956,21 +953,19 @@ ReturnValue_t CoreController::gracefulShutdownTasks(xsc::Chip chip, xsc::Copy co
   return result;
 }
 
-CoreController::~CoreController() {}
-
 void CoreController::updateSdInfoOther() {
-  if (sdInfo.pref == sd::SdCard::SLOT_0) {
+  if (sdInfo.active == sd::SdCard::SLOT_0) {
-    sdInfo.prefChar = "0";
+    sdInfo.activeChar = "0";
     sdInfo.otherChar = "1";
     sdInfo.otherState = sdInfo.currentState.second;
-    sdInfo.prefState = sdInfo.currentState.first;
+    sdInfo.activeState = sdInfo.currentState.first;
     sdInfo.other = sd::SdCard::SLOT_1;
 
-  } else if (sdInfo.pref == sd::SdCard::SLOT_1) {
+  } else if (sdInfo.active == sd::SdCard::SLOT_1) {
-    sdInfo.prefChar = "1";
+    sdInfo.activeChar = "1";
     sdInfo.otherChar = "0";
     sdInfo.otherState = sdInfo.currentState.first;
-    sdInfo.prefState = sdInfo.currentState.second;
+    sdInfo.activeState = sdInfo.currentState.second;
     sdInfo.other = sd::SdCard::SLOT_0;
   } else {
     sif::warning << "CoreController::updateSdInfoOther: Invalid SD card passed" << std::endl;
@@ -1241,10 +1236,8 @@ void CoreController::performWatchdogControlOperation() {
 }
 
 void CoreController::performMountedSdCardOperations() {
-  auto mountedSdCardOp = [&](bool &mntSwitch, sd::SdCard sdCard, std::string mntPoint) {
+  auto mountedSdCardOp = [&](sd::SdCard sdCard, std::string mntPoint) {
-    if (mntSwitch) {
+    if (not performOneShotSdCardOpsSwitch) {
-      bool sdCardMounted = sdcMan->isSdCardMounted(sdCard);
-      if (sdCardMounted and not performOneShotSdCardOpsSwitch) {
       std::ostringstream path;
       path << mntPoint << "/" << CONF_FOLDER;
       if (not std::filesystem::exists(path.str())) {
@@ -1253,32 +1246,36 @@ void CoreController::performMountedSdCardOperations() {
       initVersionFile();
       initClockFromTimeFile();
       performRebootFileHandling(false);
-        performOneShotSdCardOpsSwitch = true;
-      }
-      mntSwitch = false;
-    }
-  };
-  if (sdInfo.pref == sd::SdCard::SLOT_1) {
-    mountedSdCardOp(sdInfo.mountSwitch.second, sd::SdCard::SLOT_1, SdCardManager::SD_1_MOUNT_POINT);
-    mountedSdCardOp(sdInfo.mountSwitch.first, sd::SdCard::SLOT_0, SdCardManager::SD_0_MOUNT_POINT);
-  } else {
-    mountedSdCardOp(sdInfo.mountSwitch.first, sd::SdCard::SLOT_0, SdCardManager::SD_0_MOUNT_POINT);
-    mountedSdCardOp(sdInfo.mountSwitch.second, sd::SdCard::SLOT_1, SdCardManager::SD_1_MOUNT_POINT);
     }
     timeFileHandler();
+  };
+  bool someSdCardActive = false;
+  if (sdInfo.active == sd::SdCard::SLOT_0 and sdcMan->isSdCardUsable(sd::SdCard::SLOT_0)) {
+    mountedSdCardOp(sd::SdCard::SLOT_0, config::SD_0_MOUNT_POINT);
+    someSdCardActive = true;
+  }
+  if (sdInfo.active == sd::SdCard::SLOT_1 and sdcMan->isSdCardUsable(sd::SdCard::SLOT_1)) {
+    mountedSdCardOp(sd::SdCard::SLOT_1, config::SD_1_MOUNT_POINT);
+    someSdCardActive = true;
+  }
+  if (someSdCardActive) {
+    performOneShotSdCardOpsSwitch = true;
+  }
 }
 
 ReturnValue_t CoreController::performSdCardCheck() {
   bool mountedReadOnly = false;
   SdCardManager::SdStatePair active;
   sdcMan->getSdCardsStatus(active);
+  if (sdFsmState != SdStates::IDLE) {
+    return returnvalue::OK;
+  }
   auto sdCardCheck = [&](sd::SdCard sdCard) {
     ReturnValue_t result = sdcMan->isSdCardMountedReadOnly(sdCard, mountedReadOnly);
     if (result != returnvalue::OK) {
       sif::error << "CoreController::performSdCardCheck: Could not check "
                     "read-only mount state"
                  << std::endl;
-      mountedReadOnly = true;
     }
     if (mountedReadOnly) {
       int linuxErrno = 0;
@@ -1304,7 +1301,19 @@ ReturnValue_t CoreController::performSdCardCheck() {
   if (active.second == sd::SdState::MOUNTED) {
     sdCardCheck(sd::SdCard::SLOT_1);
   }
-
+#if OBSW_SD_CARD_MUST_BE_ON == 1
+  // This is FDIR. The core controller will attempt once to get some SD card working
+  bool someSdCardActive = false;
+  if ((sdInfo.active == sd::SdCard::SLOT_0 and sdcMan->isSdCardUsable(sd::SdCard::SLOT_0)) or
+      (sdInfo.active == sd::SdCard::SLOT_1 and sdcMan->isSdCardUsable(sd::SdCard::SLOT_1))) {
+    someSdCardActive = true;
+  }
+  if (not someSdCardActive and remountAttemptFlag) {
+    triggerEvent(NO_SD_CARD_ACTIVE);
+    initSdCardBlocking();
+    remountAttemptFlag = false;
+  }
+#endif
   return returnvalue::OK;
 }
 
@@ -1845,6 +1854,175 @@ void CoreController::readHkData() {
   }
 }
 
+const char *CoreController::getXscMountDir(xsc::Chip chip, xsc::Copy copy) {
+  if (chip == xsc::Chip::CHIP_0) {
+    if (copy == xsc::Copy::COPY_0) {
+      return CHIP_0_COPY_0_MOUNT_DIR;
+    } else if (copy == xsc::Copy::COPY_1) {
+      return CHIP_0_COPY_1_MOUNT_DIR;
+    }
+  } else if (chip == xsc::Chip::CHIP_1) {
+    if (copy == xsc::Copy::COPY_0) {
+      return CHIP_1_COPY_0_MOUNT_DIR;
+    } else if (copy == xsc::Copy::COPY_1) {
+      return CHIP_1_COPY_1_MOUNT_DIR;
+    }
+  }
+  sif::error << "Invalid chip or copy passed to CoreController::getXscMountDir" << std::endl;
+  return CHIP_0_COPY_0_MOUNT_DIR;
+}
+
+ReturnValue_t CoreController::executeSwUpdate(SwUpdateSources sourceDir, const uint8_t *data,
+                                              size_t size) {
+  using namespace std;
+  using namespace std::filesystem;
+  // At the very least, chip and copy ID need to be included in the command
+  if (size < 2) {
+    return HasActionsIF::INVALID_PARAMETERS;
+  }
+  if (data[0] > 1 or data[1] > 1) {
+    return HasActionsIF::INVALID_PARAMETERS;
+  }
+  auto chip = static_cast<xsc::Chip>(data[0]);
+  auto copy = static_cast<xsc::Copy>(data[1]);
+  const char *sourceStr = "unknown";
+  if (sourceDir == SwUpdateSources::SD_0) {
+    sourceStr = "SD 0";
+  } else if (sourceDir == SwUpdateSources::SD_1) {
+    sourceStr = "SD 1";
+  } else {
+    sourceStr = "tmp directory";
+  }
+  bool sameChipAndCopy = false;
+  if (chip == CURRENT_CHIP and copy == CURRENT_COPY) {
+    // This is problematic if the OBSW is running as a systemd service.
+    // Do not allow for now.
+    return HasActionsIF::INVALID_PARAMETERS;
+    // sameChipAndCopy = true;
+  }
+  sif::info << "Executing SW update for Chip " << static_cast<int>(data[0]) << " Copy "
+            << static_cast<int>(data[1]) << " from " << sourceStr << std::endl;
+  path prefixPath;
+  if (sourceDir == SwUpdateSources::SD_0) {
+    prefixPath = path(config::SD_0_MOUNT_POINT);
+  } else if (sourceDir == SwUpdateSources::SD_1) {
+    prefixPath = path(config::SD_1_MOUNT_POINT);
+  } else if (sourceDir == SwUpdateSources::TMP_DIR) {
+    prefixPath = path("/tmp");
+  }
+  path archivePath = prefixPath / path(config::OBSW_UPDATE_ARCHIVE_FILE_NAME);
+  if (not exists(archivePath)) {
+    return HasFileSystemIF::FILE_DOES_NOT_EXIST;
+  }
+  ostringstream cmd("tar -xJf", ios::app);
+  cmd << " " << archivePath << " -C " << prefixPath;
+  int result = system(cmd.str().c_str());
+  if (result != 0) {
+    utility::handleSystemError(result, "CoreController::executeAction: SW Update Decompression");
+  }
+  path strippedImagePath = prefixPath / path(config::STRIPPED_OBSW_BINARY_FILE_NAME);
+  if (!exists(strippedImagePath)) {
+    // TODO: Custom returnvalue?
+    return returnvalue::FAILED;
+  }
+  path obswVersionFilePath = prefixPath / path(config::OBSW_VERSION_FILE_NAME);
+  if (!exists(obswVersionFilePath)) {
+    // TODO: Custom returnvalue?
+    return returnvalue::FAILED;
+  }
+  cmd.str("");
+  cmd.clear();
+  path obswDestPath;
+  path obswVersionDestPath;
+  if (not sameChipAndCopy) {
+    cmd << "xsc_mount_copy " << std::to_string(data[0]) << " " << std::to_string(data[1]);
+    result = system(cmd.str().c_str());
+    if (result != 0) {
+      std::string contextString = "CoreController::executeAction: SW Update Mounting " +
+                                  std::to_string(data[0]) + " " + std::to_string(data[1]);
+      utility::handleSystemError(result, contextString);
+    }
+    cmd.str("");
+    cmd.clear();
+    path xscMountDest(getXscMountDir(chip, copy));
+    obswDestPath = xscMountDest / path(relative(config::OBSW_PATH, "/"));
+    obswVersionDestPath = xscMountDest / path(relative(config::OBSW_VERSION_FILE_PATH, "/"));
+  } else {
+    obswDestPath = path(config::OBSW_PATH);
+    obswVersionDestPath = path(config::OBSW_VERSION_FILE_PATH);
+    cmd << "writeprotect " << std::to_string(CURRENT_CHIP) << " " << std::to_string(CURRENT_COPY)
+        << " 0";
+    result = system(cmd.str().c_str());
+    if (result != 0) {
+      std::string contextString = "CoreController::executeAction: Unlocking current chip";
+      utility::handleSystemError(result, contextString);
+    }
+    cmd.str("");
+    cmd.clear();
+  }
+
+  cmd << "cp " << strippedImagePath << " " << obswDestPath;
+  result = system(cmd.str().c_str());
+  if (result != 0) {
+    utility::handleSystemError(result, "CoreController::executeAction: Copying SW update");
+  }
+  cmd.str("");
+  cmd.clear();
+
+  cmd << "cp " << obswVersionFilePath << " " << obswVersionDestPath;
+  result = system(cmd.str().c_str());
+  if (result != 0) {
+    utility::handleSystemError(result, "CoreController::executeAction: Copying SW version file");
+  }
+  cmd.str("");
+  cmd.clear();
+
+  // Set correct permission for both files
+  cmd << "chmod 0755 " << obswDestPath;
+  result = system(cmd.str().c_str());
+  if (result != 0) {
+    utility::handleSystemError(result,
+                               "CoreController::executeAction: Setting SW permissions 0755");
+  }
+  cmd.str("");
+  cmd.clear();
+
+  cmd << "chmod 0644 " << obswVersionDestPath;
+  result = system(cmd.str().c_str());
+  if (result != 0) {
+    utility::handleSystemError(
+        result, "CoreController::executeAction: Setting version file permission 0644");
+  }
+  cmd.str("");
+  cmd.clear();
+
+  // TODO: This takes a long time and will block the core controller.. Maybe use command executor?
+  //       For now dont care..
+  cmd << "writeprotect " << std::to_string(data[0]) << " " << std::to_string(data[1]) << " 1";
+  result = system(cmd.str().c_str());
+  if (result != 0) {
+    std::string contextString = "CoreController::executeAction: Writeprotecting " +
+                                std::to_string(data[0]) + " " + std::to_string(data[1]);
+    utility::handleSystemError(result, contextString);
+  }
+  sif::info << "SW update complete" << std::endl;
+  return HasActionsIF::EXECUTION_FINISHED;
+}
+
+bool CoreController::startSdStateMachine(sd::SdCard targetActiveSd, SdCfgMode mode,
+                                         MessageQueueId_t commander, DeviceCommandId_t actionId) {
+  if (sdFsmState != SdStates::IDLE or sdCommandingInfo.cmdPending) {
+    return false;
+  }
+  sdFsmState = SdStates::START;
+  sdInfo.active = targetActiveSd;
+  sdInfo.cfgMode = mode;
+  sdCommandingInfo.actionId = actionId;
+  sdCommandingInfo.commander = commander;
+  sdCommandingInfo.cmdPending = true;
+  return true;
+}
+
 bool CoreController::isNumber(const std::string &s) {
   return !s.empty() && std::find_if(s.begin(), s.end(),
                                     [](unsigned char c) { return !std::isdigit(c); }) == s.end();

bsp_q7s/core/CoreController.h

@@ -7,7 +7,8 @@
 #include <cstddef>
 
 #include "CoreDefinitions.h"
-#include "bsp_q7s/memory/SdCardManager.h"
+#include "OBSWConfig.h"
+#include "bsp_q7s/fs/SdCardManager.h"
 #include "events/subsystemIdRanges.h"
 #include "fsfw/controller/ExtendedControllerBase.h"
 #include "mission/devices/devicedefinitions/GPSDefinitions.h"
@@ -51,22 +52,41 @@ class CoreController : public ExtendedControllerBase {
   static constexpr char CHIP_PROT_SCRIPT[] = "get-chip-prot-status.sh";
   static constexpr char CHIP_STATE_FILE[] = "/tmp/chip_prot_status.txt";
   static constexpr char CURR_COPY_FILE[] = "/tmp/curr_copy.txt";
+
   static constexpr char CONF_FOLDER[] = "conf";
+
   static constexpr char VERSION_FILE_NAME[] = "version.txt";
   static constexpr char REBOOT_FILE_NAME[] = "reboot.txt";
   static constexpr char TIME_FILE_NAME[] = "time.txt";
+
   const std::string VERSION_FILE =
       "/" + std::string(CONF_FOLDER) + "/" + std::string(VERSION_FILE_NAME);
   const std::string REBOOT_FILE =
       "/" + std::string(CONF_FOLDER) + "/" + std::string(REBOOT_FILE_NAME);
   const std::string TIME_FILE = "/" + std::string(CONF_FOLDER) + "/" + std::string(TIME_FILE_NAME);
 
+  static constexpr char CHIP_0_COPY_0_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-nom-rootfs";
+  static constexpr char CHIP_0_COPY_1_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-gold-rootfs";
+  static constexpr char CHIP_1_COPY_0_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi1-nom-rootfs";
+  static constexpr char CHIP_1_COPY_1_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi1-gold-rootfs";
+
+  static constexpr dur_millis_t INIT_SD_CARD_CHECK_TIMEOUT = 5000;
+  static constexpr dur_millis_t DEFAULT_SD_CARD_CHECK_TIMEOUT = 60000;
+
   static constexpr ActionId_t LIST_DIRECTORY_INTO_FILE = 0;
   static constexpr ActionId_t SWITCH_REBOOT_FILE_HANDLING = 5;
   static constexpr ActionId_t RESET_REBOOT_COUNTERS = 6;
   static constexpr ActionId_t SWITCH_IMG_LOCK = 7;
   static constexpr ActionId_t SET_MAX_REBOOT_CNT = 8;
 
+  static constexpr ActionId_t OBSW_UPDATE_FROM_SD_0 = 10;
+  static constexpr ActionId_t OBSW_UPDATE_FROM_SD_1 = 11;
+  static constexpr ActionId_t OBSW_UPDATE_FROM_TMP = 12;
+
+  static constexpr ActionId_t SWITCH_TO_SD_0 = 16;
+  static constexpr ActionId_t SWITCH_TO_SD_1 = 17;
+  static constexpr ActionId_t SWITCH_TO_BOTH_SD_CARDS = 18;
+
   //! Reboot using the xsc_boot_copy command
   static constexpr ActionId_t XSC_REBOOT_OBC = 32;
   static constexpr ActionId_t MOUNT_OTHER_COPY = 33;
@@ -86,6 +106,9 @@ class CoreController : public ExtendedControllerBase {
       event::makeEvent(SUBSYSTEM_ID, 2, severity::MEDIUM);
   //! Trying to find a way how to determine that the reboot came from ProASIC3 or PCDU..
   static constexpr Event REBOOT_HW = event::makeEvent(SUBSYSTEM_ID, 3, severity::MEDIUM);
+  //! [EXPORT] : [COMMENT] No SD card was active. Core controller will attempt to re-initialize
+  //! a SD card.
+  static constexpr Event NO_SD_CARD_ACTIVE = event::makeEvent(SUBSYSTEM_ID, 4, severity::HIGH);
 
   CoreController(object_id_t objectId);
   virtual ~CoreController();
@@ -107,6 +130,7 @@ class CoreController : public ExtendedControllerBase {
   static ReturnValue_t generateChipStateFile();
   static ReturnValue_t incrementAllocationFailureCount();
   static void getCurrentBootCopy(xsc::Chip& chip, xsc::Copy& copy);
+  static const char* getXscMountDir(xsc::Chip chip, xsc::Copy copy);
 
   ReturnValue_t updateProtInfo(bool regenerateChipStateFile = true);
 
@@ -151,39 +175,46 @@ class CoreController : public ExtendedControllerBase {
     SKIP_CYCLE_BEFORE_INFO_UPDATE,
     UPDATE_INFO,
     // SD initialization done
-    IDLE,
+    IDLE
-    // Used if SD switches or mount commands are issued via telecommand
-    SET_STATE_FROM_COMMAND,
   };
+
+  enum class SwUpdateSources { SD_0, SD_1, TMP_DIR };
+
   static constexpr bool BLOCKING_SD_INIT = false;
 
   SdCardManager* sdcMan = nullptr;
   MessageQueueIF* eventQueue = nullptr;
 
-  struct SdInfo {
+  SdStates sdFsmState = SdStates::START;
-    sd::SdCard pref = sd::SdCard::NONE;
+  enum SdCfgMode { PASSIVE, COLD_REDUNDANT, HOT_REDUNDANT };
+
+  struct SdFsmParams {
+    SdCfgMode cfgMode = SdCfgMode::COLD_REDUNDANT;
+    sd::SdCard active = sd::SdCard::NONE;
     sd::SdCard other = sd::SdCard::NONE;
-    sd::SdState prefState = sd::SdState::OFF;
+    sd::SdState activeState = sd::SdState::OFF;
     sd::SdState otherState = sd::SdState::OFF;
-    std::string prefChar = "0";
+    std::string activeChar = "0";
     std::string otherChar = "1";
     std::pair<bool, bool> mountSwitch = {true, true};
-    SdStates state = SdStates::START;
     // Used to track whether a command was executed
     bool commandExecuted = true;
     bool initFinished = false;
     SdCardManager::SdStatePair currentState;
     uint16_t cycleCount = 0;
-    // These two flags are related to external commanding
-    bool commandIssued = false;
-    bool commandFinished = false;
-    sd::SdState currentlyCommandedState = sd::SdState::OFF;
-    sd::SdCard commandedCard = sd::SdCard::NONE;
-    sd::SdState commandedState = sd::SdState::OFF;
   } sdInfo;
+
+  struct SdCommanding {
+    bool cmdPending = false;
+    MessageQueueId_t commander = MessageQueueIF::NO_QUEUE;
+    DeviceCommandId_t actionId;
+  } sdCommandingInfo;
+
   RebootFile rebootFile = {};
   std::string currMntPrefix;
-  bool performOneShotSdCardOpsSwitch = true;
+  bool performOneShotSdCardOpsSwitch = false;
+  uint8_t shortSdCardCdCounter = 0;
+  Countdown sdCardCheckCd = Countdown(INIT_SD_CARD_CHECK_TIMEOUT);
 
   /**
    * Index 0: Chip 0 Copy 0
@@ -197,9 +228,13 @@ class CoreController : public ExtendedControllerBase {
 
   core::HkSet hkSet;
 
+#if OBSW_SD_CARD_MUST_BE_ON == 1
+  bool remountAttemptFlag = true;
+#endif
+
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override;
-  Countdown sdCardCheckCd = Countdown(120000);
+
   LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode, uint32_t* msToReachTheMode);
   void performMountedSdCardOperations();
@@ -211,12 +246,15 @@ class CoreController : public ExtendedControllerBase {
   ReturnValue_t initBootCopy();
   ReturnValue_t initWatchdogFifo();
   ReturnValue_t initSdCardBlocking();
+  bool startSdStateMachine(sd::SdCard targetActiveSd, SdCfgMode mode, MessageQueueId_t commander,
+                           DeviceCommandId_t actionId);
   void initPrint();
 
   ReturnValue_t sdStateMachine();
   void updateSdInfoOther();
   ReturnValue_t sdCardSetup(sd::SdCard sdCard, sd::SdState targetState, std::string sdChar,
                             bool printOutput = true);
+  ReturnValue_t executeSwUpdate(SwUpdateSources sourceDir, const uint8_t* data, size_t size);
   ReturnValue_t sdColdRedundantBlockingInit();
 
   void currentStateSetter(sd::SdCard sdCard, sd::SdState newState);

bsp_q7s/core/InitMission.cpp

@@ -1,6 +1,7 @@
 #include "bsp_q7s/core/InitMission.h"
 
 #include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <linux/InitMission.h>
 
 #include <iostream>
 #include <vector>
@@ -66,16 +67,32 @@ void initmission::initTasks() {
   void (*missedDeadlineFunc)(void) = nullptr;
 #endif
 
-  PeriodicTaskIF* coreController = factory->createPeriodicTask(
+  PeriodicTaskIF* sysCtrlTask = factory->createPeriodicTask(
       "CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
-  result = coreController->addComponent(objects::CORE_CONTROLLER);
+  result = sysCtrlTask->addComponent(objects::CORE_CONTROLLER);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
   }
+#if OBSW_ADD_SA_DEPL == 1
+  // Could add this to the core controller but the core controller does so many thing that I would
+  // prefer to have the solar array deployment in a seprate task.
+  PeriodicTaskIF* solarArrayDeplTask = factory->createPeriodicTask(
+      "SOLAR_ARRAY_DEPL", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
+  result = solarArrayDeplTask->addComponent(objects::SOLAR_ARRAY_DEPL_HANDLER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("SOLAR_ARRAY_DEPL", objects::SOLAR_ARRAY_DEPL_HANDLER);
+  }
+#endif
 
   /* TMTC Distribution */
   PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
-      "DIST", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+      "DIST", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+#if OBSW_ADD_TCPIP_BRIDGE == 1
+  result = tmTcDistributor->addComponent(objects::TMTC_BRIDGE);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("TMTC_BRIDGE", objects::TMTC_BRIDGE);
+  }
+#endif
   result = tmTcDistributor->addComponent(objects::CCSDS_PACKET_DISTRIBUTOR);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("CCSDS_DISTRIB", objects::CCSDS_PACKET_DISTRIBUTOR);
@@ -84,19 +101,16 @@ void initmission::initTasks() {
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("PUS_PACKET_DISTRIB", objects::PUS_PACKET_DISTRIBUTOR);
   }
+  result = tmTcDistributor->addComponent(objects::CFDP_DISTRIBUTOR);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("CFDP_DISTRIBUTOR", objects::CFDP_DISTRIBUTOR);
+  }
   result = tmTcDistributor->addComponent(objects::TM_FUNNEL);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("TM_FUNNEL", objects::TM_FUNNEL);
   }
 
 #if OBSW_ADD_TCPIP_BRIDGE == 1
-  // TMTC bridge
-  PeriodicTaskIF* tmtcBridgeTask = factory->createPeriodicTask(
-      "TCPIP_TMTC_BRIDGE", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-  result = tmtcBridgeTask->addComponent(objects::TMTC_BRIDGE);
-  if (result != returnvalue::OK) {
-    initmission::printAddObjectError("TMTC_BRIDGE", objects::TMTC_BRIDGE);
-  }
   PeriodicTaskIF* tmtcPollingTask = factory->createPeriodicTask(
       "TMTC_POLLING", 80, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
   result = tmtcPollingTask->addComponent(objects::TMTC_POLLING_TASK);
@@ -105,7 +119,7 @@ void initmission::initTasks() {
   }
 #endif
 
-#if OBSW_USE_CCSDS_IP_CORE == 1
+#if OBSW_ADD_CCSDS_IP_CORES == 1
   PeriodicTaskIF* ccsdsHandlerTask = factory->createPeriodicTask(
       "CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
   result = ccsdsHandlerTask->addComponent(objects::CCSDS_HANDLER);
@@ -117,24 +131,33 @@ void initmission::initTasks() {
   // If a command has not been read before the next one arrives, the old command will be
   // overwritten by the PDEC.
   PeriodicTaskIF* pdecHandlerTask = factory->createPeriodicTask(
-      "PDEC_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
+      "PDEC_HANDLER", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
   result = pdecHandlerTask->addComponent(objects::PDEC_HANDLER);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
   }
-#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+#endif /* OBSW_ADD_CCSDS_IP_CORE == 1 */
 
-  PeriodicTaskIF* acsTask = factory->createPeriodicTask(
+#if OBSW_ADD_CFDP_COMPONENTS == 1
+  PeriodicTaskIF* cfdpTask = factory->createPeriodicTask(
+      "CFDP Handler", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
+  result = cfdpTask->addComponent(objects::CFDP_HANDLER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("CFDP Handler", objects::CFDP_HANDLER);
+  }
+#endif
+
+  PeriodicTaskIF* acsCtrlTask = factory->createPeriodicTask(
       "ACS_TASK", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
 #if OBSW_ADD_GPS_CTRL == 1
-  result = acsTask->addComponent(objects::GPS_CONTROLLER);
+  result = acsCtrlTask->addComponent(objects::GPS_CONTROLLER);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("GPS_CTRL", objects::GPS_CONTROLLER);
   }
 #endif /* OBSW_ADD_GPS_CTRL */
 
 #if OBSW_ADD_ACS_CTRL == 1
-  acsTask->addComponent(objects::ACS_CONTROLLER);
+  acsCtrlTask->addComponent(objects::ACS_CONTROLLER);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("ACS_CTRL", objects::ACS_CONTROLLER);
   }
@@ -165,27 +188,31 @@ void initmission::initTasks() {
   acsTask->addComponent(objects::STAR_TRACKER);
 #endif
 
-  PeriodicTaskIF* sysTask = factory->createPeriodicTask(
+  PeriodicTaskIF* acsSysTask = factory->createPeriodicTask(
       "SYS_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
-  static_cast<void>(sysTask);
+  static_cast<void>(acsSysTask);
 #if OBSW_ADD_ACS_BOARD == 1
-  result = sysTask->addComponent(objects::ACS_BOARD_ASS);
+  result = acsSysTask->addComponent(objects::ACS_BOARD_ASS);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("ACS_BOARD_ASS", objects::ACS_BOARD_ASS);
   }
 #endif /* OBSW_ADD_ACS_HANDLERS */
 #if OBSW_ADD_RW == 1
-  result = sysTask->addComponent(objects::RW_ASS);
+  result = acsSysTask->addComponent(objects::RW_ASS);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("RW_ASS", objects::RW_ASS);
   }
 #endif
 #if OBSW_ADD_SUS_BOARD_ASS == 1
-  result = sysTask->addComponent(objects::SUS_BOARD_ASS);
+  result = acsSysTask->addComponent(objects::SUS_BOARD_ASS);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("SUS_BOARD_ASS", objects::SUS_BOARD_ASS);
   }
 #endif
+  result = acsSysTask->addComponent(objects::ACS_SUBSYSTEM);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("ACS_SUBSYSTEM", objects::ACS_SUBSYSTEM);
+  }
 
 #if OBSW_ADD_RTD_DEVICES == 1
   PeriodicTaskIF* tcsPollingTask = factory->createPeriodicTask(
@@ -194,6 +221,7 @@ void initmission::initTasks() {
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("SPI_RTD_POLLING", objects::SPI_RTD_COM_IF);
   }
+
   PeriodicTaskIF* tcsTask = factory->createPeriodicTask(
       "TCS_TASK", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
   std::array<object_id_t, EiveMax31855::NUM_RTDS> rtdIds = {
@@ -214,8 +242,7 @@ void initmission::initTasks() {
       objects::RTD_14_IC17_TCS_BOARD,
       objects::RTD_15_IC18_IMTQ,
   };
-  tcsTask->addComponent(objects::TCS_BOARD_ASS);
+
-  tcsTask->addComponent(objects::THERMAL_CONTROLLER);
   for (const auto& rtd : rtdIds) {
     tcsTask->addComponent(rtd, DeviceHandlerIF::PERFORM_OPERATION);
     tcsTask->addComponent(rtd, DeviceHandlerIF::SEND_WRITE);
@@ -223,16 +250,28 @@ void initmission::initTasks() {
     tcsTask->addComponent(rtd, DeviceHandlerIF::SEND_READ);
     tcsTask->addComponent(rtd, DeviceHandlerIF::GET_READ);
   }
-#endif /* OBSW_ADD_RTD_DEVICES */
+#endif
 
-  // FS task, task interval does not matter because it runs in permanent loop, priority low
+  PeriodicTaskIF* tcsSystemTask = factory->createPeriodicTask(
-  // because it is a non-essential background task
+      "TCS_TASK", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc);
-  PeriodicTaskIF* fsTask = factory->createPeriodicTask(
+#if OBSW_ADD_RTD_DEVICES == 1
-      "FILE_SYSTEM_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
+  result = tcsSystemTask->addComponent(objects::TCS_BOARD_ASS);
-  result = fsTask->addComponent(objects::FILE_SYSTEM_HANDLER);
   if (result != returnvalue::OK) {
-    initmission::printAddObjectError("FILE_SYSTEM_TASK", objects::FILE_SYSTEM_HANDLER);
+    initmission::printAddObjectError("TCS_BOARD_ASS", objects::TCS_BOARD_ASS);
   }
+#endif /* OBSW_ADD_RTD_DEVICES */
+#if OBSW_ADD_TCS_CTRL == 1
+  result = tcsSystemTask->addComponent(objects::THERMAL_CONTROLLER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("THERMAL_CONTROLLER", objects::THERMAL_CONTROLLER);
+  }
+#endif
+#if OBSW_ADD_HEATERS == 1
+  result = tcsSystemTask->addComponent(objects::HEATER_HANDLER);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
+  }
+#endif
 
 #if OBSW_ADD_STAR_TRACKER == 1
   PeriodicTaskIF* strHelperTask = factory->createPeriodicTask(
@@ -269,6 +308,11 @@ void initmission::initTasks() {
     initmission::printAddObjectError("PTME_TEST", objects::CCSDS_IP_CORE_BRIDGE);
   }
 #endif
+#if OBSW_ADD_SCEX_DEVICE == 1
+  PeriodicTaskIF* scexDevHandler;
+  PeriodicTaskIF* scexReaderTask;
+  scheduling::schedulingScex(*factory, scexDevHandler, scexReaderTask);
+#endif
 
   std::vector<PeriodicTaskIF*> pusTasks;
   createPusTasks(*factory, missedDeadlineFunc, pusTasks);
@@ -294,41 +338,55 @@ void initmission::initTasks() {
   tmTcDistributor->startTask();
 
 #if OBSW_ADD_TCPIP_BRIDGE == 1
-  tmtcBridgeTask->startTask();
   tmtcPollingTask->startTask();
 #endif
 
-#if OBSW_USE_CCSDS_IP_CORE == 1
+#if OBSW_ADD_CCSDS_IP_CORES == 1
   ccsdsHandlerTask->startTask();
   pdecHandlerTask->startTask();
-#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+#endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
 
-  coreController->startTask();
+  sysCtrlTask->startTask();
+#if OBSW_ADD_SA_DEPL == 1
+  solarArrayDeplTask->startTask();
+#endif
 
   taskStarter(pstTasks, "PST task vector");
   taskStarter(pusTasks, "PUS task vector");
-#if OBSW_ADD_TEST_CODE == 1
+#if OBSW_ADD_SCEX_DEVICE == 1
-  taskStarter(testTasks, "Test task vector");
+  scexDevHandler->startTask();
+  scexReaderTask->startTask();
 #endif
 
 #if OBSW_TEST_CCSDS_BRIDGE == 1
   ptmeTestTask->startTask();
 #endif
 
-  fsTask->startTask();
+#if OBSW_ADD_CFDP_COMPONENTS == 1
+  cfdpTask->startTask();
+#endif
+
 #if OBSW_ADD_STAR_TRACKER == 1
   strHelperTask->startTask();
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 
-  acsTask->startTask();
+  acsCtrlTask->startTask();
-  sysTask->startTask();
+  acsSysTask->startTask();
 #if OBSW_ADD_RTD_DEVICES == 1
   tcsPollingTask->startTask();
   tcsTask->startTask();
 #endif /* OBSW_ADD_RTD_DEVICES == 1 */
+  if (not tcsSystemTask->isEmpty()) {
+    tcsSystemTask->startTask();
+  }
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
   supvHelperTask->startTask();
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
+
+#if OBSW_ADD_TEST_CODE == 1
+  taskStarter(testTasks, "Test task vector");
+#endif
+
   sif::info << "Tasks started.." << std::endl;
 }
 
@@ -380,18 +438,6 @@ void initmission::createPstTasks(TaskFactory& factory,
     taskVec.push_back(uartPst);
   }
 
-  FixedTimeslotTaskIF* gpioPst = factory.createFixedTimeslotTask(
-      "GPIO_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.2, missedDeadlineFunc);
-  result = pst::pstGpio(gpioPst);
-  if (result != returnvalue::OK) {
-    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
-      sif::warning << "InitMission::initTasks: GPIO PST is empty" << std::endl;
-    } else {
-      sif::error << "InitMission::initTasks: Creating GPIO PST failed!" << std::endl;
-    }
-  } else {
-    taskVec.push_back(gpioPst);
-  }
 #if OBSW_ADD_I2C_TEST_CODE == 0
   FixedTimeslotTaskIF* i2cPst = factory.createFixedTimeslotTask(
       "I2C_PST", 65, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.2, missedDeadlineFunc);
@@ -446,7 +492,7 @@ void initmission::createPusTasks(TaskFactory& factory,
   taskVec.push_back(pusEvents);
 
   PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
-      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
+      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
   result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("PUS_2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
@@ -455,6 +501,7 @@ void initmission::createPusTasks(TaskFactory& factory,
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("PUS_9", objects::PUS_SERVICE_9_TIME_MGMT);
   }
+
   taskVec.push_back(pusHighPrio);
 
   PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
@@ -484,14 +531,15 @@ void initmission::createPusTasks(TaskFactory& factory,
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("PUS_201", objects::PUS_SERVICE_201_HEALTH);
   }
+  // Used for connection tests, therefore use higher priority
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_17_TEST);
+  if (result != returnvalue::OK) {
+    initmission::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
+  }
   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 != returnvalue::OK) {
-    initmission::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
-  }
   result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);

bsp_q7s/core/ObjectFactory.cpp

@@ -6,13 +6,13 @@
 #include "bsp_q7s/callbacks/pcduSwitchCb.h"
 #include "bsp_q7s/callbacks/q7sGpioCallbacks.h"
 #include "bsp_q7s/callbacks/rwSpiCallback.h"
-#include "bsp_q7s/memory/FileSystemHandler.h"
 #include "busConf.h"
 #include "ccsdsConfig.h"
 #include "devConf.h"
 #include "devices/addresses.h"
 #include "devices/gpioIds.h"
 #include "devices/powerSwitcherList.h"
+#include "eive/definitions.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "linux/ObjectFactory.h"
 #include "linux/boardtest/I2cTestClass.h"
@@ -21,6 +21,7 @@
 #include "linux/callbacks/gpioCallbacks.h"
 #include "linux/csp/CspComIF.h"
 #include "linux/devices/GPSHyperionLinuxController.h"
+#include "linux/devices/ScexUartReader.h"
 #include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
 #include "linux/devices/ploc/PlocMPSoCHandler.h"
@@ -29,23 +30,27 @@
 #include "linux/devices/ploc/PlocSupervisorHandler.h"
 #include "linux/devices/startracker/StarTrackerHandler.h"
 #include "linux/devices/startracker/StrHelper.h"
-#include "linux/obc/AxiPtmeConfig.h"
+#include "linux/ipcore/AxiPtmeConfig.h"
-#include "linux/obc/PapbVcInterface.h"
+#include "linux/ipcore/PapbVcInterface.h"
-#include "linux/obc/PdecHandler.h"
+#include "linux/ipcore/PdecHandler.h"
-#include "linux/obc/Ptme.h"
+#include "linux/ipcore/Ptme.h"
-#include "linux/obc/PtmeConfig.h"
+#include "linux/ipcore/PtmeConfig.h"
 #include "mission/csp/CspCookie.h"
-#include "mission/system/RwAssembly.h"
 #include "mission/system/fdir/AcsBoardFdir.h"
 #include "mission/system/fdir/GomspacePowerFdir.h"
 #include "mission/system/fdir/RtdFdir.h"
 #include "mission/system/fdir/SusFdir.h"
 #include "mission/system/fdir/SyrlinksFdir.h"
-#include "tmtc/apid.h"
+#include "mission/system/objects/AcsSubsystem.h"
+#include "mission/system/objects/RwAssembly.h"
+#include "mission/system/objects/TcsBoardAssembly.h"
+#include "mission/system/tree/acsModeTree.h"
 #include "tmtc/pusIds.h"
 #if OBSW_TEST_LIBGPIOD == 1
 #include "linux/boardtest/LibgpiodTest.h"
 #endif
+#include <mission/devices/ImtqHandler.h>
+
 #include <sstream>
 
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
@@ -69,7 +74,6 @@
 #include "mission/devices/BpxBatteryHandler.h"
 #include "mission/devices/GyroADIS1650XHandler.h"
 #include "mission/devices/HeaterHandler.h"
-#include "mission/devices/IMTQHandler.h"
 #include "mission/devices/Max31865PT1000Handler.h"
 #include "mission/devices/P60DockHandler.h"
 #include "mission/devices/PCDUHandler.h"
@@ -87,19 +91,19 @@
 #include "mission/devices/devicedefinitions/RwDefinitions.h"
 #include "mission/devices/devicedefinitions/SyrlinksDefinitions.h"
 #include "mission/devices/devicedefinitions/payloadPcduDefinitions.h"
-#include "mission/system/AcsBoardAssembly.h"
+#include "mission/system/objects/AcsBoardAssembly.h"
-#include "mission/tmtc/CCSDSHandler.h"
+#include "mission/tmtc/CcsdsIpCoreHandler.h"
-#include "mission/tmtc/TmFunnel.h"
+#include "mission/tmtc/TmFunnelHandler.h"
 #include "mission/tmtc/VirtualChannel.h"
 
 ResetArgs RESET_ARGS_GNSS;
 
 void Factory::setStaticFrameworkObjectIds() {
   PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
-  PusServiceBase::PACKET_DESTINATION = objects::TM_FUNNEL;
+  PusServiceBase::PACKET_DESTINATION = objects::PUS_TM_FUNNEL;
 
   CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
-  CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
+  CommandingServiceBase::defaultPacketDestination = objects::PUS_TM_FUNNEL;
 
 #if OBSW_Q7S_EM == 1
   DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
@@ -107,14 +111,6 @@ void Factory::setStaticFrameworkObjectIds() {
   DeviceHandlerBase::powerSwitcherId = objects::PCDU_HANDLER;
 #endif /* OBSW_Q7S_EM == 1 */
 
-#if OBSW_TM_TO_PTME == 1
-  TmFunnel::downlinkDestination = objects::CCSDS_HANDLER;
-#else
-  TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
-#endif /* OBSW_TM_TO_PTME == 1 */
-  // No storage object for now.
-  TmFunnel::storageDestination = objects::NO_OBJECT;
-
   LocalDataPoolManager::defaultHkDestination = objects::PUS_SERVICE_3_HOUSEKEEPING;
 
   VerificationReporter::DEFAULT_RECEIVER = objects::PUS_SERVICE_1_VERIFICATION;
@@ -151,10 +147,8 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, Ua
   new CspComIF(objects::CSP_COM_IF);
   *i2cComIF = new I2cComIF(objects::I2C_COM_IF);
   *uartComIF = new UartComIF(objects::UART_COM_IF);
-  *spiMainComIF = new SpiComIF(objects::SPI_MAIN_COM_IF, q7s::SPI_DEFAULT_DEV, *gpioComIF);
+  *spiMainComIF = new SpiComIF(objects::SPI_MAIN_COM_IF, q7s::SPI_DEFAULT_DEV, **gpioComIF);
-  *spiRWComIF = new SpiComIF(objects::SPI_RW_COM_IF, q7s::SPI_RW_DEV, *gpioComIF);
+  *spiRWComIF = new SpiComIF(objects::SPI_RW_COM_IF, q7s::SPI_RW_DEV, **gpioComIF);
-  /* Adding gpios for chip select decoding to the gpioComIf */
-  q7s::gpioCallbacks::initSpiCsDecoder(*gpioComIF);
 }
 
 void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher) {
@@ -199,8 +193,11 @@ void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchI
 #endif
 }
 
-void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
+ReturnValue_t ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
   using namespace gpio;
+  if (gpioComIF == nullptr) {
+    return returnvalue::FAILED;
+  }
   GpioCookie* gpioCookieRadSensor = new GpioCookie;
   std::stringstream consumer;
   consumer << "0x" << std::hex << objects::RAD_SENSOR;
@@ -226,12 +223,14 @@ void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
 #if OBSW_DEBUG_RAD_SENSOR == 1
   radSensor->enablePeriodicDataPrint(true);
 #endif
+  return returnvalue::OK;
 }
 
 void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF,
                                              PowerSwitchIF* pwrSwitcher) {
   using namespace gpio;
   GpioCookie* gpioCookieAcsBoard = new GpioCookie();
+  std::vector<std::reference_wrapper<DeviceHandlerBase>> assemblyChildren;
 
   std::stringstream consumer;
   GpiodRegularByLineName* gpio = nullptr;
@@ -336,11 +335,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
   SpiCookie* spiCookie =
       new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
                     spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
-  auto mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_0_LIS3_HANDLER, objects::SPI_MAIN_COM_IF,
+  auto mgmLis3Handler0 = new MgmLIS3MDLHandler(
-                                              spiCookie, spi::LIS3_TRANSITION_DELAY);
+      objects::MGM_0_LIS3_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::LIS3_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::MGM_0_LIS3_HANDLER);
-  mgmLis3Handler->setCustomFdir(fdir);
+  mgmLis3Handler0->setCustomFdir(fdir);
-  static_cast<void>(mgmLis3Handler);
+  assemblyChildren.push_back(*mgmLis3Handler0);
 #if OBSW_TEST_ACS == 1
   mgmLis3Handler->setStartUpImmediately();
   mgmLis3Handler->setToGoToNormalMode(true);
@@ -351,13 +350,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
   spiCookie =
       new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, RM3100::MAX_BUFFER_SIZE,
                     spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
-  auto mgmRm3100Handler =
+  auto mgmRm3100Handler1 =
       new MgmRM3100Handler(objects::MGM_1_RM3100_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
                            spi::RM3100_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::MGM_1_RM3100_HANDLER);
-  mgmRm3100Handler->setCustomFdir(fdir);
+  mgmRm3100Handler1->setCustomFdir(fdir);
-  mgmRm3100Handler->setParent(objects::ACS_BOARD_ASS);
+  assemblyChildren.push_back(*mgmRm3100Handler1);
-  static_cast<void>(mgmRm3100Handler);
 #if OBSW_TEST_ACS == 1
   mgmRm3100Handler->setStartUpImmediately();
   mgmRm3100Handler->setToGoToNormalMode(true);
@@ -368,12 +366,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
   spiCookie =
       new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
                     spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
-  mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_2_LIS3_HANDLER, objects::SPI_MAIN_COM_IF,
+  auto* mgmLis3Handler2 = new MgmLIS3MDLHandler(
-                                         spiCookie, spi::LIS3_TRANSITION_DELAY);
+      objects::MGM_2_LIS3_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::LIS3_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::MGM_2_LIS3_HANDLER);
-  mgmLis3Handler->setCustomFdir(fdir);
+  mgmLis3Handler2->setCustomFdir(fdir);
-  mgmLis3Handler->setParent(objects::ACS_BOARD_ASS);
+  assemblyChildren.push_back(*mgmLis3Handler2);
-  static_cast<void>(mgmLis3Handler);
 #if OBSW_TEST_ACS == 1
   mgmLis3Handler->setStartUpImmediately();
   mgmLis3Handler->setToGoToNormalMode(true);
@@ -384,11 +381,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
   spiCookie =
       new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, RM3100::MAX_BUFFER_SIZE,
                     spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
-  mgmRm3100Handler = new MgmRM3100Handler(objects::MGM_3_RM3100_HANDLER, objects::SPI_MAIN_COM_IF,
+  auto* mgmRm3100Handler3 =
-                                          spiCookie, spi::RM3100_TRANSITION_DELAY);
+      new MgmRM3100Handler(objects::MGM_3_RM3100_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
+                           spi::RM3100_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::MGM_3_RM3100_HANDLER);
-  mgmRm3100Handler->setCustomFdir(fdir);
+  mgmRm3100Handler3->setCustomFdir(fdir);
-  mgmRm3100Handler->setParent(objects::ACS_BOARD_ASS);
+  assemblyChildren.push_back(*mgmRm3100Handler3);
 #if OBSW_TEST_ACS == 1
   mgmRm3100Handler->setStartUpImmediately();
   mgmRm3100Handler->setToGoToNormalMode(true);
@@ -406,8 +404,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
                                ADIS1650X::Type::ADIS16505);
   fdir = new AcsBoardFdir(objects::GYRO_0_ADIS_HANDLER);
   adisHandler->setCustomFdir(fdir);
-  adisHandler->setParent(objects::ACS_BOARD_ASS);
+  assemblyChildren.push_back(*adisHandler);
-  static_cast<void>(adisHandler);
 #if OBSW_TEST_ACS == 1
   adisHandler->setStartUpImmediately();
   adisHandler->setToGoToNormalModeImmediately();
@@ -418,12 +415,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
   // Gyro 1 Side A
   spiCookie = new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, L3GD20H::MAX_BUFFER_SIZE,
                             spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
-  auto gyroL3gHandler = new GyroHandlerL3GD20H(
+  auto gyroL3gHandler1 = new GyroHandlerL3GD20H(
       objects::GYRO_1_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::GYRO_1_L3G_HANDLER);
-  gyroL3gHandler->setCustomFdir(fdir);
+  gyroL3gHandler1->setCustomFdir(fdir);
-  gyroL3gHandler->setParent(objects::ACS_BOARD_ASS);
+  assemblyChildren.push_back(*gyroL3gHandler1);
-  static_cast<void>(gyroL3gHandler);
 #if OBSW_TEST_ACS == 1
   gyroL3gHandler->setStartUpImmediately();
   gyroL3gHandler->setToGoToNormalMode(true);
@@ -439,7 +435,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
                                          spiCookie, ADIS1650X::Type::ADIS16505);
   fdir = new AcsBoardFdir(objects::GYRO_2_ADIS_HANDLER);
   adisHandler->setCustomFdir(fdir);
-  adisHandler->setParent(objects::ACS_BOARD_ASS);
+  assemblyChildren.push_back(*adisHandler);
 #if OBSW_TEST_ACS == 1
   adisHandler->setStartUpImmediately();
   adisHandler->setToGoToNormalModeImmediately();
@@ -447,11 +443,11 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
   // Gyro 3 Side B
   spiCookie = new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, L3GD20H::MAX_BUFFER_SIZE,
                             spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
-  gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_3_L3G_HANDLER, objects::SPI_MAIN_COM_IF,
+  auto gyroL3gHandler3 = new GyroHandlerL3GD20H(
-                                          spiCookie, spi::L3G_TRANSITION_DELAY);
+      objects::GYRO_3_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY);
   fdir = new AcsBoardFdir(objects::GYRO_3_L3G_HANDLER);
-  gyroL3gHandler->setCustomFdir(fdir);
+  gyroL3gHandler3->setCustomFdir(fdir);
-  gyroL3gHandler->setParent(objects::ACS_BOARD_ASS);
+  assemblyChildren.push_back(*gyroL3gHandler3);
 #if OBSW_TEST_ACS == 1
   gyroL3gHandler->setStartUpImmediately();
   gyroL3gHandler->setToGoToNormalMode(true);
@@ -468,14 +464,22 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
   auto gpsCtrl =
       new GPSHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT, debugGps);
   gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);
-
   AcsBoardHelper acsBoardHelper = AcsBoardHelper(
       objects::MGM_0_LIS3_HANDLER, objects::MGM_1_RM3100_HANDLER, objects::MGM_2_LIS3_HANDLER,
       objects::MGM_3_RM3100_HANDLER, objects::GYRO_0_ADIS_HANDLER, objects::GYRO_1_L3G_HANDLER,
       objects::GYRO_2_ADIS_HANDLER, objects::GYRO_3_L3G_HANDLER, objects::GPS_CONTROLLER);
-  auto acsAss = new AcsBoardAssembly(objects::ACS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher,
+  auto acsAss =
-                                     acsBoardHelper, gpioComIF);
+      new AcsBoardAssembly(objects::ACS_BOARD_ASS, pwrSwitcher, acsBoardHelper, gpioComIF);
   static_cast<void>(acsAss);
+  for (auto& assChild : assemblyChildren) {
+    ReturnValue_t result = assChild.get().connectModeTreeParent(*acsAss);
+    if (result != returnvalue::OK) {
+      sif::error << "Connecting assembly for ACS board component " << assChild.get().getObjectId()
+                 << " failed" << std::endl;
+    }
+  }
+  gpsCtrl->connectModeTreeParent(*acsAss);
+  acsAss->connectModeTreeParent(satsystem::ACS_SUBSYSTEM);
 #endif /* OBSW_ADD_ACS_HANDLERS == 1 */
 }
 
@@ -538,7 +542,8 @@ void ObjectFactory::createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwi
                     pcdu::Switches::PDU2_CH3_TCS_BOARD_HEATER_IN_8V);
 }
 
-void ObjectFactory::createSolarArrayDeploymentComponents() {
+void ObjectFactory::createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitcher,
+                                                         GpioIF& gpioIF) {
   using namespace gpio;
   GpioCookie* solarArrayDeplCookie = new GpioCookie;
   GpiodRegularByLineName* gpio = nullptr;
@@ -551,12 +556,14 @@ void ObjectFactory::createSolarArrayDeploymentComponents() {
   gpio = new GpiodRegularByLineName(q7s::gpioNames::SA_DPL_PIN_1, consumer.str(), Direction::OUT,
                                     Levels::LOW);
   solarArrayDeplCookie->addGpio(gpioIds::DEPLSA2, gpio);
+  ReturnValue_t result = gpioIF.addGpios(solarArrayDeplCookie);
+  if (result != returnvalue::OK) {
+    sif::error << "Adding Solar Array Deployment GPIO cookie failed" << std::endl;
+  }
 
-  // TODO: Find out burn time. For now set to 1000 ms.
+  new SolarArrayDeploymentHandler(objects::SOLAR_ARRAY_DEPL_HANDLER, gpioIF, pwrSwitcher,
-  new SolarArrayDeploymentHandler(objects::SOLAR_ARRAY_DEPL_HANDLER, objects::GPIO_IF,
-                                  solarArrayDeplCookie, objects::PCDU_HANDLER,
                                   pcdu::Switches::PDU2_CH5_DEPLOYMENT_MECHANISM_8V,
-                                  gpioIds::DEPLSA1, gpioIds::DEPLSA2, 1000);
+                                  gpioIds::DEPLSA1, gpioIds::DEPLSA2, *SdCardManager::instance());
 }
 
 void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
@@ -685,13 +692,21 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF,
   }
 
   RwHelper rwHelper(rwIds);
-  auto* rwAss = new RwAssembly(objects::RW_ASS, objects::NO_OBJECT, pwrSwitcher,
+  auto* rwAss =
-                               pcdu::Switches::PDU2_CH2_RW_5V, rwHelper);
+      new RwAssembly(objects::RW_ASS, pwrSwitcher, pcdu::Switches::PDU2_CH2_RW_5V, rwHelper);
-  static_cast<void>(rwAss);
+  for (uint8_t idx = 0; idx < rws.size(); idx++) {
+    ReturnValue_t result = rws[idx]->connectModeTreeParent(*rwAss);
+    if (result != returnvalue::OK) {
+      sif::error << "Connecting RW " << static_cast<int>(idx) << " to RW assembly failed"
+                 << std::endl;
+    }
+  }
+  rwAss->connectModeTreeParent(satsystem::ACS_SUBSYSTEM);
 #endif /* OBSW_ADD_RW == 1 */
 }
 
-void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
+ReturnValue_t ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF,
+                                                   CcsdsIpCoreHandler** ipCoreHandler) {
   using namespace gpio;
   // GPIO definitions of signals connected to the virtual channel interfaces of the PTME IP Core
   GpioCookie* gpioCookiePtmeIp = new GpioCookie;
@@ -754,18 +769,19 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
 #else
   static const uint32_t TRANSMITTER_TIMEOUT = 900000;  // 15 minutes
 #endif
-  CCSDSHandler* ccsdsHandler = new CCSDSHandler(
+  *ipCoreHandler = new CcsdsIpCoreHandler(
       objects::CCSDS_HANDLER, objects::PTME, objects::CCSDS_PACKET_DISTRIBUTOR, ptmeConfig,
       gpioComIF, gpioIds::RS485_EN_TX_CLOCK, gpioIds::RS485_EN_TX_DATA, TRANSMITTER_TIMEOUT);
   VirtualChannel* vc = nullptr;
   vc = new VirtualChannel(ccsds::VC0, common::VC0_QUEUE_SIZE, objects::CCSDS_HANDLER);
-  ccsdsHandler->addVirtualChannel(ccsds::VC0, vc);
+  (*ipCoreHandler)->addVirtualChannel(ccsds::VC0, vc);
   vc = new VirtualChannel(ccsds::VC1, common::VC1_QUEUE_SIZE, objects::CCSDS_HANDLER);
-  ccsdsHandler->addVirtualChannel(ccsds::VC1, vc);
+  (*ipCoreHandler)->addVirtualChannel(ccsds::VC1, vc);
   vc = new VirtualChannel(ccsds::VC2, common::VC2_QUEUE_SIZE, objects::CCSDS_HANDLER);
-  ccsdsHandler->addVirtualChannel(ccsds::VC2, vc);
+  (*ipCoreHandler)->addVirtualChannel(ccsds::VC2, vc);
   vc = new VirtualChannel(ccsds::VC3, common::VC3_QUEUE_SIZE, objects::CCSDS_HANDLER);
-  ccsdsHandler->addVirtualChannel(ccsds::VC3, vc);
+  (*ipCoreHandler)->addVirtualChannel(ccsds::VC3, vc);
+
   GpioCookie* gpioCookiePdec = new GpioCookie;
   consumer.str("");
   consumer << "0x" << std::hex << objects::PDEC_HANDLER;
@@ -774,8 +790,13 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
                                     Levels::LOW);
   gpioCookiePdec->addGpio(gpioIds::PDEC_RESET, gpio);
   gpioChecker(gpioComIF->addGpios(gpioCookiePdec), "PDEC");
+  struct UioNames uioNames {};
+  uioNames.configMemory = q7s::UIO_PDEC_CONFIG_MEMORY;
+  uioNames.ramMemory = q7s::UIO_PDEC_RAM;
+  uioNames.registers = q7s::UIO_PDEC_REGISTERS;
+  uioNames.irq = q7s::UIO_PDEC_IRQ;
   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);
+                  uioNames);
   GpioCookie* gpioRS485Chip = new GpioCookie;
   gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_TX_CLOCK, "RS485 Transceiver",
                                     Direction::OUT, Levels::LOW);
@@ -791,6 +812,7 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
                                     Direction::OUT, Levels::LOW);
   gpioRS485Chip->addGpio(gpioIds::RS485_EN_RX_DATA, gpio);
   gpioChecker(gpioComIF->addGpios(gpioRS485Chip), "RS485 Transceiver");
+  return returnvalue::OK;
 }
 
 void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
@@ -865,6 +887,7 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
   new I2cTestClass(objects::I2C_TEST, q7s::I2C_DEFAULT_DEV);
 #endif
 #if OBSW_ADD_UART_TEST_CODE == 1
+  // auto* reader= new ScexUartReader(objects::SCEX_UART_READER);
   new UartTestClass(objects::UART_TEST);
 #endif
 }
@@ -879,14 +902,16 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
       new StarTrackerHandler(objects::STAR_TRACKER, objects::UART_COM_IF, starTrackerCookie,
                              strHelper, pcdu::PDU1_CH2_STAR_TRACKER_5V);
   starTracker->setPowerSwitcher(pwrSwitcher);
+  starTracker->connectModeTreeParent(satsystem::ACS_SUBSYSTEM);
 }
 
 void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher) {
   I2cCookie* imtqI2cCookie =
       new I2cCookie(addresses::IMTQ, IMTQ::MAX_REPLY_SIZE, q7s::I2C_DEFAULT_DEV);
-  auto imtqHandler = new IMTQHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie,
+  auto imtqHandler = new ImtqHandler(objects::IMTQ_HANDLER, objects::I2C_COM_IF, imtqI2cCookie,
                                      pcdu::Switches::PDU1_CH3_MGT_5V);
   imtqHandler->setPowerSwitcher(pwrSwitcher);
+  imtqHandler->connectModeTreeParent(satsystem::ACS_SUBSYSTEM);
   static_cast<void>(imtqHandler);
 #if OBSW_TEST_IMTQ == 1
   imtqHandler->setStartUpImmediately();
@@ -908,10 +933,7 @@ void ObjectFactory::createBpxBatteryComponent() {
 #endif
 }
 
-void ObjectFactory::createMiscComponents() {
+void ObjectFactory::createMiscComponents() { new PlocMemoryDumper(objects::PLOC_MEMORY_DUMPER); }
-  new FileSystemHandler(objects::FILE_SYSTEM_HANDLER);
-  new PlocMemoryDumper(objects::PLOC_MEMORY_DUMPER);
-}
 
 void ObjectFactory::testAcsBrdAss(AcsBoardAssembly* acsAss) {
   CommandMessage msg;

bsp_q7s/core/ObjectFactory.h

@@ -2,6 +2,9 @@
 #define BSP_Q7S_OBJECTFACTORY_H_
 
 #include <fsfw/returnvalues/returnvalue.h>
+#include <mission/tmtc/CcsdsIpCoreHandler.h>
+#include <mission/tmtc/CfdpTmFunnel.h>
+#include <mission/tmtc/PusTmFunnel.h>
 
 #include <string>
 
@@ -26,18 +29,18 @@ void createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher
 void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
                             PowerSwitchIF* pwrSwitcher);
 void createTmpComponents();
-void createRadSensorComponent(LinuxLibgpioIF* gpioComIF);
+ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF);
 void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF,
                               PowerSwitchIF* pwrSwitcher);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable);
 void createImtqComponents(PowerSwitchIF* pwrSwitcher);
 void createBpxBatteryComponent();
 void createStrComponents(PowerSwitchIF* pwrSwitcher);
-void createSolarArrayDeploymentComponents();
+void createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitcher, GpioIF& gpioIF);
 void createSyrlinksComponents(PowerSwitchIF* pwrSwitcher);
 void createPayloadComponents(LinuxLibgpioIF* gpioComIF);
 void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher);
-void createCcsdsComponents(LinuxLibgpioIF* gpioComIF);
+ReturnValue_t createCcsdsComponents(LinuxLibgpioIF* gpioComIF, CcsdsIpCoreHandler** ipCoreHandler);
 void createMiscComponents();
 
 void createTestComponents(LinuxLibgpioIF* gpioComIF);

bsp_q7s/em/emObjectFactory.cpp

@@ -1,3 +1,4 @@
+#include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
 #include <fsfw/health/HealthTableIF.h>
 #include <fsfw/power/DummyPowerSwitcher.h>
 
@@ -5,9 +6,9 @@
 #include "bsp_q7s/core/CoreController.h"
 #include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
-#include "commonObjects.h"
 #include "devConf.h"
 #include "dummies/helpers.h"
+#include "eive/objects.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 #include "linux/ObjectFactory.h"
 #include "linux/callbacks/gpioCallbacks.h"
@@ -16,7 +17,9 @@
 void ObjectFactory::produce(void* args) {
   ObjectFactory::setStatics();
   HealthTableIF* healthTable = nullptr;
-  ObjectFactory::produceGenericObjects(&healthTable);
+  PusTmFunnel* pusFunnel = nullptr;
+  CfdpTmFunnel* cfdpFunnel = nullptr;
+  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
   UartComIF* uartComIF = nullptr;
@@ -24,39 +27,54 @@ void ObjectFactory::produce(void* args) {
   I2cComIF* i2cComIF = nullptr;
   SpiComIF* spiRwComIF = nullptr;
   createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF, &spiRwComIF);
+  /* Adding gpios for chip select decoding to the gpioComIf */
+  q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
+  gpioCallbacks::disableAllDecoder(gpioComIF);
 
   // Hardware is usually not connected to EM, so we need to create dummies which replace lower
   // level components.
   dummy::DummyCfg dummyCfg;
   dummyCfg.addCoreCtrlCfg = false;
+#if OBSW_ADD_SYRLINKS == 1
+  dummyCfg.addSyrlinksDummies = false;
+#endif
   dummy::createDummies(dummyCfg);
 
-  createTmpComponents();
   new CoreController(objects::CORE_CONTROLLER);
 
-  gpioCallbacks::disableAllDecoder(gpioComIF);
   PowerSwitchIF* pwrSwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
+  static_cast<void>(pwrSwitcher);
 
   // Regular FM code, does not work for EM if the hardware is not connected
   // createPcduComponents(gpioComIF, &pwrSwitcher);
   // createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
   // createSyrlinksComponents(pwrSwitcher);
   // createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
-  createRadSensorComponent(gpioComIF);
+  // createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
+  // createTmpComponents();
+  // createSolarArrayDeploymentComponents();
+  // createPayloadComponents(gpioComIF);
+  // createHeaterComponents(gpioComIF, pwrSwitcher, healthTable);
+
+  // TODO: Careful! Switching this on somehow messes with the communication with the ProASIC
+  //       and will cause xsc_boot_copy commands to always boot to 0 0
+  // createRadSensorComponent(gpioComIF);
 
 #if OBSW_ADD_ACS_BOARD == 1
   createAcsBoardComponents(gpioComIF, uartComIF, pwrSwitcher);
 #endif
-  createHeaterComponents(gpioComIF, pwrSwitcher, healthTable);
-  createSolarArrayDeploymentComponents();
-
-  createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
-  createPayloadComponents(gpioComIF);
 
 #if OBSW_ADD_MGT == 1
   createImtqComponents(pwrSwitcher);
 #endif
+
+#if OBSW_ADD_SYRLINKS == 1
+  createSyrlinksComponents(pwrSwitcher);
+#endif /* OBSW_ADD_SYRLINKS == 1 */
+
+#if OBSW_ADD_RW == 1
   createReactionWheelComponents(gpioComIF, pwrSwitcher);
+#endif
 
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
   createBpxBatteryComponent();
@@ -65,14 +83,20 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_STAR_TRACKER == 1
   createStrComponents(pwrSwitcher);
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
-#if OBSW_USE_CCSDS_IP_CORE == 1
+#if OBSW_ADD_CCSDS_IP_CORES == 1
-  createCcsdsComponents(gpioComIF);
+  CcsdsIpCoreHandler* ipCoreHandler = nullptr;
-#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+  createCcsdsComponents(gpioComIF, &ipCoreHandler);
+#if OBSW_TM_TO_PTME == 1
+  ObjectFactory::addTmtcIpCoresToFunnels(*ipCoreHandler, *pusFunnel, *cfdpFunnel);
+#endif
+#endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
   /* Test Task */
 #if OBSW_ADD_TEST_CODE == 1
   createTestComponents(gpioComIF);
 #endif /* OBSW_ADD_TEST_CODE == 1 */
-
+#if OBSW_ADD_SCEX_DEVICE == 1
-  createMiscComponents();
+  createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), true,
-  createAcsController();
+                       std::nullopt);
+#endif
+  createAcsController(true);
 }

bsp_q7s/fmObjectFactory.cpp

@@ -1,18 +1,24 @@
+#include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
+#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
+
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
 #include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
-#include "commonObjects.h"
 #include "devConf.h"
+#include "eive/objects.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 #include "linux/ObjectFactory.h"
 #include "linux/callbacks/gpioCallbacks.h"
 #include "mission/core/GenericFactory.h"
+#include "mission/system/tree/acsModeTree.h"
 
 void ObjectFactory::produce(void* args) {
   ObjectFactory::setStatics();
   HealthTableIF* healthTable = nullptr;
-  ObjectFactory::produceGenericObjects(&healthTable);
+  PusTmFunnel* pusFunnel = nullptr;
+  CfdpTmFunnel* cfdpFunnel = nullptr;
+  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel);
 
   LinuxLibgpioIF* gpioComIF = nullptr;
   UartComIF* uartComIF = nullptr;
@@ -21,10 +27,11 @@ void ObjectFactory::produce(void* args) {
   PowerSwitchIF* pwrSwitcher = nullptr;
   SpiComIF* spiRwComIF = nullptr;
   createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF, &spiRwComIF);
-  createTmpComponents();
+  /* Adding gpios for chip select decoding to the gpioComIf */
-  new CoreController(objects::CORE_CONTROLLER);
+  q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
-
   gpioCallbacks::disableAllDecoder(gpioComIF);
+
+  new CoreController(objects::CORE_CONTROLLER);
   createPcduComponents(gpioComIF, &pwrSwitcher);
   createRadSensorComponent(gpioComIF);
   createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
@@ -33,7 +40,10 @@ void ObjectFactory::produce(void* args) {
   createAcsBoardComponents(gpioComIF, uartComIF, pwrSwitcher);
 #endif
   createHeaterComponents(gpioComIF, pwrSwitcher, healthTable);
-  createSolarArrayDeploymentComponents();
+#if OBSW_ADD_TMP_DEVICES == 1
+  createTmpComponents();
+#endif
+  createSolarArrayDeploymentComponents(*pwrSwitcher, *gpioComIF);
   createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
 #if OBSW_ADD_SYRLINKS == 1
   createSyrlinksComponents(pwrSwitcher);
@@ -53,9 +63,18 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_STAR_TRACKER == 1
   createStrComponents(pwrSwitcher);
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
-#if OBSW_USE_CCSDS_IP_CORE == 1
+#if OBSW_ADD_CCSDS_IP_CORES == 1
-  createCcsdsComponents(gpioComIF);
+  CcsdsIpCoreHandler* ipCoreHandler = nullptr;
-#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+  createCcsdsComponents(gpioComIF, &ipCoreHandler);
+#if OBSW_TM_TO_PTME == 1
+  ObjectFactory::addTmtcIpCoresToFunnels(*ipCoreHandler, *pusFunnel, *cfdpFunnel);
+#endif
+#endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
+
+#if OBSW_ADD_SCEX_DEVICE == 1
+  createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), false,
+                       pcdu::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
+#endif
   /* Test Task */
 #if OBSW_ADD_TEST_CODE == 1
   createTestComponents(gpioComIF);
@@ -63,5 +82,6 @@ void ObjectFactory::produce(void* args) {
 
   createMiscComponents();
   createThermalController();
-  createAcsController();
+  createAcsController(true);
+  satsystem::initAcsSubsystem(objects::NO_OBJECT);
 }

bsp_q7s/fs/CMakeLists.txt

@@ -0,0 +1,2 @@
+target_sources(${OBSW_NAME} PRIVATE helpers.cpp SdCardManager.cpp
+                                    FilesystemHelper.cpp)

bsp_q7s/fs/FilesystemHelper.cpp

@@ -3,8 +3,9 @@
 #include <filesystem>
 #include <fstream>
 
-#include "bsp_q7s/memory/SdCardManager.h"
+#include "SdCardManager.h"
-#include "fsfw/serviceinterface/ServiceInterfaceStream.h"
+#include "eive/definitions.h"
+#include "fsfw/serviceinterface.h"
 
 FilesystemHelper::FilesystemHelper() {}
 
@@ -14,15 +15,14 @@ ReturnValue_t FilesystemHelper::checkPath(std::string path) {
     sif::warning << "FilesystemHelper::checkPath: Invalid SD card manager" << std::endl;
     return returnvalue::FAILED;
   }
-  if (path.substr(0, sizeof(SdCardManager::SD_0_MOUNT_POINT)) ==
+  if (path.substr(0, sizeof(config::SD_0_MOUNT_POINT)) == std::string(config::SD_0_MOUNT_POINT)) {
-      std::string(SdCardManager::SD_0_MOUNT_POINT)) {
+    if (!sdcMan->isSdCardUsable(sd::SLOT_0)) {
-    if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
       sif::warning << "FilesystemHelper::checkPath: SD card 0 not mounted" << std::endl;
       return SD_NOT_MOUNTED;
     }
-  } else if (path.substr(0, sizeof(SdCardManager::SD_1_MOUNT_POINT)) ==
+  } else if (path.substr(0, sizeof(config::SD_1_MOUNT_POINT)) ==
-             std::string(SdCardManager::SD_1_MOUNT_POINT)) {
+             std::string(config::SD_1_MOUNT_POINT)) {
-    if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
+    if (!sdcMan->isSdCardUsable(sd::SLOT_0)) {
       sif::warning << "FilesystemHelper::checkPath: SD card 1 not mounted" << std::endl;
       return SD_NOT_MOUNTED;
     }

bsp_q7s/fs/FilesystemHelper.h

@@ -3,7 +3,7 @@
 
 #include <string>
 
-#include "commonClassIds.h"
+#include "eive/resultClassIds.h"
 #include "fsfw/returnvalues/returnvalue.h"
 
 /**

bsp_q7s/fs/SdCardManager.cpp

@@ -10,11 +10,12 @@
 #include <memory>
 
 #include "OBSWConfig.h"
-#include "common/config/commonObjects.h"
+#include "bsp_q7s/memory/scratchApi.h"
+#include "eive/definitions.h"
+#include "eive/objects.h"
 #include "fsfw/ipc/MutexFactory.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "linux/utility/utility.h"
-#include "scratchApi.h"
 
 SdCardManager* SdCardManager::INSTANCE = nullptr;
 
@@ -26,8 +27,7 @@ SdCardManager::SdCardManager() : SystemObject(objects::SDC_MANAGER), cmdExecutor
   }
   uint8_t prefSdRaw = 0;
   result = scratch::readNumber(scratch::PREFERED_SDC_KEY, prefSdRaw);
-  result = mutex->unlockMutex();
+  if (mutex->unlockMutex() != returnvalue::OK) {
-  if (result != returnvalue::OK) {
     sif::error << "SdCardManager::SdCardManager: Mutex unlock failed" << std::endl;
   }
 
@@ -212,6 +212,9 @@ ReturnValue_t SdCardManager::getSdCardsStatus(SdStatePair& active) {
   while (std::getline(sdStatus, line)) {
     processSdStatusLine(active, line, idx, currentSd);
   }
+  if (active.first != sd::SdState::MOUNTED && active.second != sd::SdState::MOUNTED) {
+    sdCardActive = false;
+  }
   return returnvalue::OK;
 }
 
@@ -229,10 +232,10 @@ ReturnValue_t SdCardManager::mountSdCard(sd::SdCard sdCard) {
   string mountPoint;
   if (sdCard == sd::SdCard::SLOT_0) {
     mountDev = SD_0_DEV_NAME;
-    mountPoint = SD_0_MOUNT_POINT;
+    mountPoint = config::SD_0_MOUNT_POINT;
   } else if (sdCard == sd::SdCard::SLOT_1) {
     mountDev = SD_1_DEV_NAME;
-    mountPoint = SD_1_MOUNT_POINT;
+    mountPoint = config::SD_1_MOUNT_POINT;
   }
   if (not filesystem::exists(mountDev)) {
     sif::warning << "SdCardManager::mountSdCard: Device file does not exists. Make sure to"
@@ -265,9 +268,9 @@ ReturnValue_t SdCardManager::unmountSdCard(sd::SdCard sdCard) {
   }
   string mountPoint;
   if (sdCard == sd::SdCard::SLOT_0) {
-    mountPoint = SD_0_MOUNT_POINT;
+    mountPoint = config::SD_0_MOUNT_POINT;
   } else if (sdCard == sd::SdCard::SLOT_1) {
-    mountPoint = SD_1_MOUNT_POINT;
+    mountPoint = config::SD_1_MOUNT_POINT;
   }
   if (not filesystem::exists(mountPoint)) {
     sif::error << "SdCardManager::unmountSdCard: Default mount point " << mountPoint
@@ -300,11 +303,6 @@ ReturnValue_t SdCardManager::sanitizeState(SdStatePair* statusPair, sd::SdCard p
     blocking = true;
     resetNonBlockingState = true;
   }
-  if (prefSdCard == sd::SdCard::NONE) {
-    result = getPreferredSdCard();
-    if (result != returnvalue::OK) {
-    }
-  }
   if (statusPair == nullptr) {
     sdStatusPtr = std::make_unique<SdStatePair>();
     statusPair = sdStatusPtr.get();
@@ -379,7 +377,7 @@ void SdCardManager::processSdStatusLine(std::pair<sd::SdState, sd::SdState>& act
   idx++;
 }
 
-sd::SdCard SdCardManager::getPreferredSdCard() const {
+std::optional<sd::SdCard> SdCardManager::getPreferredSdCard() const {
   MutexGuard mg(mutex);
   auto res = mg.getLockResult();
   if (res != returnvalue::OK) {
@@ -412,13 +410,9 @@ ReturnValue_t SdCardManager::updateSdCardStateFile() {
   return result;
 }
 
-std::string SdCardManager::getCurrentMountPrefix() const {
+const std::string& SdCardManager::getCurrentMountPrefix() const {
   MutexGuard mg(mutex);
-  if (sdInfo.active == sd::SdCard::SLOT_0) {
+  return currentPrefix;
-    return SD_0_MOUNT_POINT;
-  } else {
-    return SD_1_MOUNT_POINT;
-  }
 }
 
 SdCardManager::OpStatus SdCardManager::checkCurrentOp(Operations& currentOp) {
@@ -465,7 +459,14 @@ void SdCardManager::setBlocking(bool blocking) { this->blocking = blocking; }
 
 void SdCardManager::setPrintCommandOutput(bool print) { this->printCmdOutput = print; }
 
-bool SdCardManager::isSdCardMounted(sd::SdCard sdCard) {
+bool SdCardManager::isSdCardUsable(std::optional<sd::SdCard> sdCard) {
+  {
+    MutexGuard mg(mutex);
+    if (markedUnusable) {
+      return false;
+    }
+  }
+
   SdCardManager::SdStatePair active;
   ReturnValue_t result = this->getSdCardsStatus(active);
 
@@ -473,20 +474,30 @@ bool SdCardManager::isSdCardMounted(sd::SdCard sdCard) {
     sif::debug << "SdCardManager::isSdCardMounted: Failed to get SD card active state";
     return false;
   }
+  if (not sdCard) {
+    if (active.first == sd::MOUNTED or active.second == sd::MOUNTED) {
+      return true;
+    }
+    return false;
+  }
   if (sdCard == sd::SLOT_0) {
     if (active.first == sd::MOUNTED) {
       return true;
     } else {
       return false;
     }
-  } else if (sdCard == sd::SLOT_1) {
+  }
+  if (sdCard == sd::SLOT_1) {
     if (active.second == sd::MOUNTED) {
       return true;
     } else {
       return false;
     }
-  } else {
+  }
-    sif::debug << "SdCardManager::isSdCardMounted: Unknown SD card specified" << std::endl;
+  if (sdCard == sd::BOTH) {
+    if (active.first == sd::MOUNTED && active.second == sd::MOUNTED) {
+      return true;
+    }
   }
   return false;
 }
@@ -494,9 +505,11 @@ bool SdCardManager::isSdCardMounted(sd::SdCard sdCard) {
 ReturnValue_t SdCardManager::isSdCardMountedReadOnly(sd::SdCard sdcard, bool& readOnly) {
   std::ostringstream command;
   if (sdcard == sd::SdCard::SLOT_0) {
-    command << "grep -q '" << SD_0_MOUNT_POINT << " vfat ro,' /proc/mounts";
+    command << "grep -q '" << config::SD_0_MOUNT_POINT << " vfat ro,' /proc/mounts";
+  } else if (sdcard == sd::SdCard::SLOT_1) {
+    command << "grep -q '" << config::SD_1_MOUNT_POINT << " vfat ro,' /proc/mounts";
   } else {
-    command << "grep -q '" << SD_1_MOUNT_POINT << " vfat ro,' /proc/mounts";
+    return returnvalue::FAILED;
   }
   ReturnValue_t result = cmdExecutor.load(command.str(), true, false);
   if (result != returnvalue::OK) {
@@ -523,9 +536,9 @@ ReturnValue_t SdCardManager::isSdCardMountedReadOnly(sd::SdCard sdcard, bool& re
 ReturnValue_t SdCardManager::remountReadWrite(sd::SdCard sdcard) {
   std::ostringstream command;
   if (sdcard == sd::SdCard::SLOT_0) {
-    command << "mount -o remount,rw " << SD_0_DEV_NAME << " " << SD_0_MOUNT_POINT;
+    command << "mount -o remount,rw " << SD_0_DEV_NAME << " " << config::SD_0_MOUNT_POINT;
   } else {
-    command << "mount -o remount,rw " << SD_1_DEV_NAME << " " << SD_1_MOUNT_POINT;
+    command << "mount -o remount,rw " << SD_1_DEV_NAME << " " << config::SD_1_MOUNT_POINT;
   }
   ReturnValue_t result = cmdExecutor.load(command.str(), true, false);
   if (result != returnvalue::OK) {
@@ -552,6 +565,25 @@ ReturnValue_t SdCardManager::performFsck(sd::SdCard sdcard, bool printOutput, in
   return result;
 }
 
-void SdCardManager::setActiveSdCard(sd::SdCard sdCard) { sdInfo.active = sdCard; }
+void SdCardManager::setActiveSdCard(sd::SdCard sdCard) {
+  MutexGuard mg(mutex);
+  sdInfo.active = sdCard;
+  if (sdInfo.active == sd::SdCard::SLOT_0) {
+    currentPrefix = config::SD_0_MOUNT_POINT;
+  } else {
+    currentPrefix = config::SD_1_MOUNT_POINT;
+  }
+}
 
-sd::SdCard SdCardManager::getActiveSdCard() const { return sdInfo.active; }
+std::optional<sd::SdCard> SdCardManager::getActiveSdCard() const {
+  MutexGuard mg(mutex);
+  if (markedUnusable) {
+    return std::nullopt;
+  }
+  return sdInfo.active;
+}
+
+void SdCardManager::markUnusable() {
+  MutexGuard mg(mutex);
+  markedUnusable = true;
+}

bsp_q7s/fs/SdCardManager.h

@@ -64,8 +64,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
   // C++17 does not support constexpr std::string yet
   static constexpr char SD_0_DEV_NAME[] = "/dev/mmcblk0p1";
   static constexpr char SD_1_DEV_NAME[] = "/dev/mmcblk1p1";
-  static constexpr char SD_0_MOUNT_POINT[] = "/mnt/sd0";
+
-  static constexpr char SD_1_MOUNT_POINT[] = "/mnt/sd1";
   static constexpr char SD_STATE_FILE[] = "/tmp/sd_status.txt";
 
   virtual ~SdCardManager();
@@ -92,7 +91,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    * @param sdCard
    * @return
    */
-  sd::SdCard getPreferredSdCard() const override;
+  std::optional<sd::SdCard> getPreferredSdCard() const override;
 
   /**
    * Switch on the specified SD card.
@@ -159,7 +158,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    * mounted
    * @return
    */
-  sd::SdCard getActiveSdCard() const override;
+  std::optional<sd::SdCard> getActiveSdCard() const override;
 
   /**
    * Unmount the specified SD card. This is recommended before switching it off. The SD card
@@ -188,7 +187,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    * @param prefSdCardPtr
    * @return
    */
-  std::string getCurrentMountPrefix() const override;
+  const std::string& getCurrentMountPrefix() const override;
 
   OpStatus checkCurrentOp(Operations& currentOp);
 
@@ -207,7 +206,7 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
    *
    * @return  true if mounted, otherwise false
    */
-  bool isSdCardMounted(sd::SdCard sdCard) override;
+  bool isSdCardUsable(std::optional<sd::SdCard> sdCard) override;
 
   ReturnValue_t isSdCardMountedReadOnly(sd::SdCard sdcard, bool& readOnly);
 
@@ -215,11 +214,15 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
 
   ReturnValue_t performFsck(sd::SdCard sdcard, bool printOutput, int& linuxError);
 
+  void markUnusable();
+
  private:
   CommandExecutor cmdExecutor;
   Operations currentOp = Operations::IDLE;
   bool blocking = false;
+  bool sdCardActive = true;
   bool printCmdOutput = true;
+  bool markedUnusable = false;
   MutexIF* mutex = nullptr;
 
   SdCardManager();

bsp_q7s/fs/helpers.cpp

@@ -0,0 +1,8 @@
+#include "helpers.h"
+
+std::filesystem::path fshelpers::getPrefixedPath(SdCardManager &man,
+                                                 std::filesystem::path pathWihtoutPrefix) {
+  auto prefix = man.getCurrentMountPrefix();
+  auto resPath = prefix / pathWihtoutPrefix;
+  return resPath;
+}

bsp_q7s/fs/helpers.h

@@ -0,0 +1,14 @@
+#ifndef BSP_Q7S_MEMORY_HELPERS_H_
+#define BSP_Q7S_MEMORY_HELPERS_H_
+
+#include <filesystem>
+
+#include "SdCardManager.h"
+
+namespace fshelpers {
+
+std::filesystem::path getPrefixedPath(SdCardManager& man, std::filesystem::path pathWihtoutPrefix);
+
+}
+
+#endif /* BSP_Q7S_MEMORY_HELPERS_H_ */

bsp_q7s/memory/CMakeLists.txt

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

bsp_q7s/memory/FileSystemHandler.cpp

@@ -1,238 +0,0 @@
-#include "FileSystemHandler.h"
-
-#include <cstring>
-#include <filesystem>
-#include <fstream>
-
-#include "bsp_q7s/core/CoreController.h"
-#include "fsfw/ipc/QueueFactory.h"
-#include "fsfw/memory/GenericFileSystemMessage.h"
-#include "fsfw/tasks/TaskFactory.h"
-
-FileSystemHandler::FileSystemHandler(object_id_t fileSystemHandler)
-    : SystemObject(fileSystemHandler) {
-  auto mqArgs = MqArgs(this->getObjectId());
-  mq = QueueFactory::instance()->createMessageQueue(FS_MAX_QUEUE_SIZE,
-                                                    MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
-}
-
-FileSystemHandler::~FileSystemHandler() { QueueFactory::instance()->deleteMessageQueue(mq); }
-
-ReturnValue_t FileSystemHandler::performOperation(uint8_t unsignedChar) {
-  while (true) {
-    try {
-      fileSystemHandlerLoop();
-    } catch (std::bad_alloc& e) {
-      // Restart OBSW, hints at a memory leak
-      sif::error << "Allocation error in FileSystemHandler::performOperation" << e.what()
-                 << std::endl;
-      // Set up an error file or a special flag in the scratch buffer for these cases
-      triggerEvent(CoreController::ALLOC_FAILURE, 0, 0);
-      CoreController::incrementAllocationFailureCount();
-    }
-  }
-}
-
-void FileSystemHandler::fileSystemHandlerLoop() {
-  CommandMessage filemsg;
-  ReturnValue_t result = returnvalue::OK;
-  while (true) {
-    if (opCounter % 5 == 0) {
-      if (coreCtrl->sdInitFinished()) {
-        fileSystemCheckup();
-      }
-    }
-    result = mq->receiveMessage(&filemsg);
-    if (result == MessageQueueIF::EMPTY) {
-      break;
-    } else if (result != returnvalue::FAILED) {
-      sif::warning << "FileSystemHandler::performOperation: Message reception failed!" << std::endl;
-      break;
-    }
-    Command_t command = filemsg.getCommand();
-    switch (command) {
-      case (GenericFileSystemMessage::CMD_CREATE_DIRECTORY): {
-        break;
-      }
-      case (GenericFileSystemMessage::CMD_CREATE_FILE): {
-        break;
-      }
-    }
-    opCounter++;
-  }
-
-  // This task will have a low priority and will run permanently in the background
-  // so we will just run in a permanent loop here and check file system
-  // messages permanently
-  opCounter++;
-  TaskFactory::instance()->delayTask(1000);
-}
-
-void FileSystemHandler::fileSystemCheckup() {
-  SdCardManager::SdStatePair statusPair;
-  sdcMan->getSdCardsStatus(statusPair);
-  sd::SdCard preferredSdCard = sdcMan->getPreferredSdCard();
-  if ((preferredSdCard == sd::SdCard::SLOT_0) and (statusPair.first == sd::SdState::MOUNTED)) {
-    currentMountPrefix = SdCardManager::SD_0_MOUNT_POINT;
-  } else if ((preferredSdCard == sd::SdCard::SLOT_1) and
-             (statusPair.second == sd::SdState::MOUNTED)) {
-    currentMountPrefix = SdCardManager::SD_1_MOUNT_POINT;
-  } else {
-    std::string sdString;
-    if (preferredSdCard == sd::SdCard::SLOT_0) {
-      sdString = "0";
-    } else {
-      sdString = "1";
-    }
-    sif::warning << "FileSystemHandler::performOperation: "
-                    "Inconsistent state detected"
-                 << std::endl;
-    sif::warning << "Preferred SD card is " << sdString
-                 << " but does not appear to be mounted. Attempting fix.." << std::endl;
-    // This function will appear to fix the inconsistent state
-    ReturnValue_t result = sdcMan->sanitizeState(&statusPair, preferredSdCard);
-    if (result != returnvalue::OK) {
-      // Oh no.
-      triggerEvent(SdCardManager::SANITIZATION_FAILED, 0, 0);
-      sif::error << "FileSystemHandler::fileSystemCheckup: Sanitization failed" << std::endl;
-    }
-  }
-}
-
-MessageQueueId_t FileSystemHandler::getCommandQueue() const { return mq->getId(); }
-
-ReturnValue_t FileSystemHandler::initialize() {
-  coreCtrl = ObjectManager::instance()->get<CoreController>(objects::CORE_CONTROLLER);
-  if (coreCtrl == nullptr) {
-    sif::error << "FileSystemHandler::initialize: Could not retrieve core controller handle"
-               << std::endl;
-  }
-  sdcMan = SdCardManager::instance();
-  sd::SdCard preferredSdCard = sdcMan->getPreferredSdCard();
-  if (preferredSdCard == sd::SdCard::SLOT_0) {
-    currentMountPrefix = SdCardManager::SD_0_MOUNT_POINT;
-  } else if (preferredSdCard == sd::SdCard::SLOT_1) {
-    currentMountPrefix = SdCardManager::SD_1_MOUNT_POINT;
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t FileSystemHandler::appendToFile(const char* repositoryPath, const char* filename,
-                                              const uint8_t* data, size_t size,
-                                              uint16_t packetNumber, FileSystemArgsIF* args) {
-  auto path = getInitPath(args) / repositoryPath / filename;
-  if (not std::filesystem::exists(path)) {
-    return FILE_DOES_NOT_EXIST;
-  }
-  std::ofstream file(path, std::ios_base::app | std::ios_base::out);
-  file.write(reinterpret_cast<const char*>(data), size);
-  if (not file.good()) {
-    return GENERIC_FILE_ERROR;
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t FileSystemHandler::createFile(const char* repositoryPath, const char* filename,
-                                            const uint8_t* data, size_t size,
-                                            FileSystemArgsIF* args) {
-  auto path = getInitPath(args) / filename;
-  if (std::filesystem::exists(path)) {
-    return FILE_ALREADY_EXISTS;
-  }
-  std::ofstream file(path);
-  file.write(reinterpret_cast<const char*>(data), size);
-  if (not file.good()) {
-    return GENERIC_FILE_ERROR;
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t FileSystemHandler::removeFile(const char* repositoryPath, const char* filename,
-                                            FileSystemArgsIF* args) {
-  auto path = getInitPath(args) / repositoryPath / filename;
-  if (not std::filesystem::exists(path)) {
-    return FILE_DOES_NOT_EXIST;
-  }
-  int result = std::remove(path.c_str());
-  if (result != 0) {
-    sif::warning << "FileSystemHandler::deleteFile: Failed with code " << result << std::endl;
-    return GENERIC_FILE_ERROR;
-  }
-  return returnvalue::OK;
-}
-
-ReturnValue_t FileSystemHandler::createDirectory(const char* repositoryPath, const char* dirname,
-                                                 bool createParentDirs, FileSystemArgsIF* args) {
-  auto path = getInitPath(args) / repositoryPath / dirname;
-  if (std::filesystem::exists(path)) {
-    return DIRECTORY_ALREADY_EXISTS;
-  }
-  if (std::filesystem::create_directory(path)) {
-    return returnvalue::OK;
-  }
-  sif::warning << "Creating directory " << path << " failed" << std::endl;
-  return GENERIC_FILE_ERROR;
-}
-
-ReturnValue_t FileSystemHandler::removeDirectory(const char* repositoryPath, const char* dirname,
-                                                 bool deleteRecurively, FileSystemArgsIF* args) {
-  auto path = getInitPath(args) / repositoryPath / dirname;
-  if (not std::filesystem::exists(path)) {
-    return DIRECTORY_DOES_NOT_EXIST;
-  }
-  std::error_code err;
-  if (not deleteRecurively) {
-    if (std::filesystem::remove(path, err)) {
-      return returnvalue::OK;
-    } else {
-      // Check error code. Most probably denied permissions because folder is not empty
-      sif::warning << "FileSystemHandler::removeDirectory: Deleting directory failed with "
-                      "code "
-                   << err.value() << ": " << strerror(err.value()) << std::endl;
-      if (err.value() == ENOTEMPTY) {
-        return DIRECTORY_NOT_EMPTY;
-      } else {
-        return GENERIC_FILE_ERROR;
-      }
-    }
-  } else {
-    if (std::filesystem::remove_all(path, err)) {
-      return returnvalue::OK;
-    } else {
-      sif::warning << "FileSystemHandler::removeDirectory: Deleting directory failed with "
-                      "code "
-                   << err.value() << ": " << strerror(err.value()) << std::endl;
-      // Check error code
-      if (err.value() == ENOTEMPTY) {
-        return DIRECTORY_NOT_EMPTY;
-      } else {
-        return GENERIC_FILE_ERROR;
-      }
-    }
-  }
-
-  return returnvalue::OK;
-}
-
-ReturnValue_t FileSystemHandler::renameFile(const char* repositoryPath, const char* oldFilename,
-                                            const char* newFilename, FileSystemArgsIF* args) {
-  auto basepath = getInitPath(args) / repositoryPath;
-  std::filesystem::rename(basepath / oldFilename, basepath / newFilename);
-  return returnvalue::OK;
-}
-
-void FileSystemHandler::parseCfg(FsCommandCfg* cfg, bool& useMountPrefix) {
-  if (cfg != nullptr) {
-    useMountPrefix = cfg->useMountPrefix;
-  }
-}
-
-std::filesystem::path FileSystemHandler::getInitPath(FileSystemArgsIF* args) {
-  bool useMountPrefix = true;
-  parseCfg(reinterpret_cast<FsCommandCfg*>(args), useMountPrefix);
-  std::string path;
-  if (useMountPrefix) {
-    path = currentMountPrefix;
-  }
-  return std::filesystem::path(path);
-}

bsp_q7s/memory/FileSystemHandler.h

@@ -1,68 +0,0 @@
-#ifndef BSP_Q7S_MEMORY_FILESYSTEMHANDLER_H_
-#define BSP_Q7S_MEMORY_FILESYSTEMHANDLER_H_
-
-#include <filesystem>
-#include <string>
-
-#include "OBSWConfig.h"
-#include "SdCardManager.h"
-#include "eive/definitions.h"
-#include "fsfw/ipc/MessageQueueIF.h"
-#include "fsfw/memory/HasFileSystemIF.h"
-#include "fsfw/objectmanager/SystemObject.h"
-#include "fsfw/tasks/ExecutableObjectIF.h"
-
-class CoreController;
-
-class FileSystemHandler : public SystemObject, public ExecutableObjectIF, public HasFileSystemIF {
- public:
-  struct FsCommandCfg : public FileSystemArgsIF {
-    // Can be used to automatically use mount prefix of active SD card.
-    // Otherwise, the operator has to specify the full path to the mounted SD card as well.
-    bool useMountPrefix = false;
-  };
-
-  FileSystemHandler(object_id_t fileSystemHandler);
-  virtual ~FileSystemHandler();
-
-  ReturnValue_t performOperation(uint8_t) override;
-
-  ReturnValue_t initialize() override;
-
-  /**
-   * Function to get the MessageQueueId_t of the implementing object
-   * @return MessageQueueId_t of the object
-   */
-  MessageQueueId_t getCommandQueue() const override;
-  ReturnValue_t appendToFile(const char* repositoryPath, const char* filename, const uint8_t* data,
-                             size_t size, uint16_t packetNumber,
-                             FileSystemArgsIF* args = nullptr) override;
-  ReturnValue_t createFile(const char* repositoryPath, const char* filename,
-                           const uint8_t* data = nullptr, size_t size = 0,
-                           FileSystemArgsIF* args = nullptr) override;
-  ReturnValue_t removeFile(const char* repositoryPath, const char* filename,
-                           FileSystemArgsIF* args = nullptr) override;
-  ReturnValue_t createDirectory(const char* repositoryPath, const char* dirname,
-                                bool createParentDirs, FileSystemArgsIF* args = nullptr) override;
-  ReturnValue_t removeDirectory(const char* repositoryPath, const char* dirname,
-                                bool deleteRecurively = false,
-                                FileSystemArgsIF* args = nullptr) override;
-  ReturnValue_t renameFile(const char* repositoryPath, const char* oldFilename,
-                           const char* newFilename, FileSystemArgsIF* args = nullptr) override;
-
- private:
-  CoreController* coreCtrl = nullptr;
-  MessageQueueIF* mq = nullptr;
-  std::string currentMountPrefix = SdCardManager::SD_0_MOUNT_POINT;
-  static constexpr uint32_t FS_MAX_QUEUE_SIZE = config::OBSW_FILESYSTEM_HANDLER_QUEUE_SIZE;
-
-  SdCardManager* sdcMan = nullptr;
-  uint8_t opCounter = 0;
-
-  void fileSystemHandlerLoop();
-  void fileSystemCheckup();
-  std::filesystem::path getInitPath(FileSystemArgsIF* args);
-  void parseCfg(FsCommandCfg* cfg, bool& useMountPrefix);
-};
-
-#endif /* BSP_Q7S_MEMORY_FILESYSTEMMANAGER_H_ */

bsp_q7s/memory/scratchApi.cpp

@@ -1,8 +1,8 @@
 #include "scratchApi.h"
 
 ReturnValue_t scratch::writeString(std::string name, std::string string) {
-  std::ostringstream oss;
+  std::ostringstream oss("xsc_scratch write ", std::ostringstream::ate);
-  oss << "xsc_scratch write " << name << " \"" << string << "\"";
+  oss << name << " \"" << string << "\"";
   int result = std::system(oss.str().c_str());
   if (result != 0) {
     utility::handleSystemError(result, "scratch::writeString");
@@ -39,8 +39,8 @@ ReturnValue_t scratch::readString(std::string key, std::string &string) {
 }
 
 ReturnValue_t scratch::clearValue(std::string key) {
-  std::ostringstream oss;
+  std::ostringstream oss("xsc_scratch clear ", std::ostringstream::ate);
-  oss << "xsc_scratch clear " << key;
+  oss << key;
   int result = std::system(oss.str().c_str());
   if (result != 0) {
     utility::handleSystemError(result, "scratch::clearValue");

bsp_q7s/memory/scratchApi.h

@@ -94,8 +94,8 @@ ReturnValue_t readToFile(std::string name, std::ifstream& file, std::string& fil
 
 template <typename T, class = typename std::enable_if<std::is_integral<T>::value>::type>
 inline ReturnValue_t writeNumber(std::string key, T num) noexcept {
-  std::ostringstream oss;
+  std::ostringstream oss("xsc_scratch write ", std::ostringstream::ate);
-  oss << "xsc_scratch write " << key << " " << std::to_string(num);
+  oss << key << " " << std::to_string(num);
   int result = std::system(oss.str().c_str());
   if (result != 0) {
     utility::handleSystemError(result, "scratch::writeNumber");

bsp_te0720_1cfa/InitMission.cpp

@@ -107,7 +107,7 @@ void initmission::initTasks() {
   }
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
 
-#if OBSW_USE_CCSDS_IP_CORE == 1
+#if OBSW_ADD_CCSDS_IP_CORES == 1
   PeriodicTaskIF* ccsdsHandlerTask = factory->createPeriodicTask(
       "CCSDS_HANDLER", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
   result = ccsdsHandlerTask->addComponent(objects::CCSDS_HANDLER);
@@ -124,7 +124,7 @@ void initmission::initTasks() {
   if (result != returnvalue::OK) {
     initmission::printAddObjectError("PDEC Handler", objects::PDEC_HANDLER);
   }
-#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
+#endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
 
   auto taskStarter = [](std::vector<PeriodicTaskIF*>& taskVector, std::string name) {
     for (const auto& task : taskVector) {
@@ -140,10 +140,10 @@ void initmission::initTasks() {
   tmtcDistributor->startTask();
   tmtcBridgeTask->startTask();
   tmtcPollingTask->startTask();
-#if OBSW_USE_CCSDS_IP_CORE == 1
+#if OBSW_ADD_CCSDS_IP_CORE == 1
   pdecHandlerTask->startTask();
   ccsdsHandlerTask->startTask();
-#endif /* #if OBSW_USE_CCSDS_IP_CORE == 1 */
+#endif /* #if OBSW_ADD_CCSDS_IP_CORE == 1 */
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
   supvHelperTask->startTask();
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */

bsp_te0720_1cfa/OBSWConfig.h.in

@@ -13,7 +13,7 @@
 /** All of the following flags should be enabled for mission code  */
 /*******************************************************************/
 
-#define OBSW_USE_CCSDS_IP_CORE                      0
+#define OBSW_ADD_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

common/config/commonConfig.cpp

@@ -1,8 +1,11 @@
 #include "commonConfig.h"
 
+#include "eive/definitions.h"
 #include "fsfw/tmtcpacket/ccsds/defs.h"
-#include "tmtc/apid.h"
 
 const fsfw::Version common::OBSW_VERSION{OBSW_VERSION_MAJOR, OBSW_VERSION_MINOR,
                                          OBSW_VERSION_REVISION, OBSW_VERSION_CST_GIT_SHA1};
-const uint16_t common::PUS_PACKET_ID = ccsds::getTcSpacePacketIdFromApid(apid::EIVE_OBSW);
+const uint16_t common::PUS_PACKET_ID =
+    ccsds::getTcSpacePacketIdFromApid(config::EIVE_PUS_APID, true);
+const uint16_t common::CFDP_PACKET_ID =
+    ccsds::getTcSpacePacketIdFromApid(config::EIVE_CFDP_APID, false);

common/config/commonConfig.h.in

@@ -25,6 +25,8 @@ debugging. */
 // CCSDS IP Cores. 
 #define OBSW_USE_TMTC_TCP_BRIDGE            1
 
+#define OBSW_ADD_CFDP_COMPONENTS            1
+
 namespace common {
 
 static constexpr uint8_t OBSW_VERSION_MAJOR = @OBSW_VERSION_MAJOR@;
@@ -39,6 +41,7 @@ static constexpr uint32_t OBSW_MAX_SCHEDULED_TCS = @OBSW_MAX_SCHEDULED_TCS@;
 extern const fsfw::Version OBSW_VERSION;
 
 extern const uint16_t PUS_PACKET_ID;
+extern const uint16_t CFDP_PACKET_ID;
 
 static constexpr uint32_t CCSDS_HANDLER_QUEUE_SIZE = 50;
 static constexpr uint8_t NUMBER_OF_VIRTUAL_CHANNELS = 4;

common/config/devConf.h

@@ -55,6 +55,7 @@ namespace uart {
 
 static constexpr size_t HYPERION_GPS_REPLY_MAX_BUFFER = 1024;
 static constexpr UartBaudRate SYRLINKS_BAUD = UartBaudRate::RATE_38400;
+static constexpr UartBaudRate SCEX_BAUD = UartBaudRate::RATE_115200;
 static constexpr UartBaudRate GNSS_BAUD = UartBaudRate::RATE_9600;
 static constexpr UartBaudRate PLOC_MPSOC_BAUD = UartBaudRate::RATE_115200;
 static constexpr UartBaudRate PLOC_SUPV_BAUD = UartBaudRate::RATE_115200;

common/config/eive/definitions.h

@@ -5,6 +5,21 @@
 
 namespace config {
 
+static constexpr char SD_0_MOUNT_POINT[] = "/mnt/sd0";
+static constexpr char SD_1_MOUNT_POINT[] = "/mnt/sd1";
+
+static constexpr char OBSW_UPDATE_ARCHIVE_FILE_NAME[] = "eive-sw-update.tar.xz";
+static constexpr char STRIPPED_OBSW_BINARY_FILE_NAME[] = "eive-obsw-stripped";
+static constexpr char OBSW_VERSION_FILE_NAME[] = "obsw_version.txt";
+
+static constexpr char OBSW_PATH[] = "/usr/bin/eive-obsw";
+static constexpr char OBSW_VERSION_FILE_PATH[] = "/usr/share/eive-obsw/obsw_version.txt";
+
+static constexpr uint16_t EIVE_PUS_APID = 0x65;
+static constexpr uint16_t EIVE_CFDP_APID = 0x66;
+static constexpr uint16_t EIVE_LOCAL_CFDP_ENTITY_ID = EIVE_CFDP_APID;
+static constexpr uint16_t EIVE_GROUND_CFDP_ENTITY_ID = 1;
+
 static constexpr uint32_t PL_PCDU_TRANSITION_TIMEOUT_MS = 20 * 60 * 1000;
 static constexpr uint32_t LONGEST_MODE_TIMEOUT_SECONDS = PL_PCDU_TRANSITION_TIMEOUT_MS / 1000;
 
@@ -19,6 +34,15 @@ static constexpr uint8_t LIVE_TM = 0;
 static constexpr uint32_t MAX_PATH_SIZE = 100;
 static constexpr uint32_t MAX_FILENAME_SIZE = 50;
 
+static constexpr uint32_t SA_DEPL_INIT_BUFFER_SECS = 120;
+// Burn time for autonomous deployment
+static constexpr uint32_t SA_DEPL_BURN_TIME_SECS = 180;
+static constexpr uint32_t SA_DEPL_WAIT_TIME_SECS = 45 * 60;
+// HW constraints (current limit) mean that the GPIO channels need to be switched on in alternation
+static constexpr uint32_t SA_DEPL_CHANNEL_ALTERNATION_INTERVAL_SECS = 5;
+// Maximum allowed burn time allowed by the software.
+static constexpr uint32_t SA_DEPL_MAX_BURN_TIME = 180;
+
 }  // namespace config
 
 #endif /* COMMON_CONFIG_DEFINITIONS_H_ */

common/config/eive/eventSubsystemIds.h

@@ -4,6 +4,7 @@
 #include <fsfw/events/fwSubsystemIdRanges.h>
 
 namespace SUBSYSTEM_ID {
+
 enum : uint8_t {
   COMMON_SUBSYSTEM_ID_START = FW_SUBSYSTEM_ID_RANGE,
   ACS_SUBSYSTEM = 112,
@@ -32,7 +33,10 @@ enum : uint8_t {
   ACU_HANDLER = 135,
   PLOC_SUPV_HELPER = 136,
   SYRLINKS = 137,
+  SCEX_HANDLER = 138,
+  CONFIGHANDLER = 139,
   COMMON_SUBSYSTEM_ID_END
+
 };
 }
 

common/config/eive/objects.h

@@ -20,6 +20,7 @@ enum commonObjects : uint32_t {
   THERMAL_CONTROLLER = 0x43400001,
   ACS_CONTROLLER = 0x43000002,
   CORE_CONTROLLER = 0x43000003,
+  GLOBAL_JSON_CFG = 0x43000006,
 
   /* 0x44 ('D') for device handlers */
   MGM_0_LIS3_HANDLER = 0x44120006,
@@ -57,6 +58,7 @@ enum commonObjects : uint32_t {
   PLOC_MPSOC_HANDLER = 0x44330015,
   PLOC_SUPERVISOR_HANDLER = 0x44330016,
   PLOC_SUPERVISOR_HELPER = 0x44330017,
+  SCEX = 0x44330032,
   SOLAR_ARRAY_DEPL_HANDLER = 0x444100A2,
   HEATER_HANDLER = 0x444100A4,
 
@@ -107,6 +109,9 @@ enum commonObjects : uint32_t {
 
   SYRLINKS_HK_HANDLER = 0x445300A3,
 
+  /* 0x49 ('I') for Communication Interfaces */
+  SPI_RTD_COM_IF = 0x49020006,
+
   // 0x60 for other stuff
   HEATER_0_PLOC_PROC_BRD = 0x60000000,
   HEATER_1_PCDU_BRD = 0x60000001,
@@ -121,7 +126,14 @@ enum commonObjects : uint32_t {
   ACS_BOARD_ASS = 0x73000001,
   SUS_BOARD_ASS = 0x73000002,
   TCS_BOARD_ASS = 0x73000003,
-  RW_ASS = 0x73000004
+  RW_ASS = 0x73000004,
+  ACS_SUBSYSTEM = 0x73010001,
+  EIVE_SYSTEM = 0x73010000,
+  CFDP_HANDLER = 0x73000005,
+  CFDP_DISTRIBUTOR = 0x73000006,
+  TM_FUNNEL = 0x73000100,
+  PUS_TM_FUNNEL = 0x73000101,
+  CFDP_TM_FUNNEL = 0x73000102,
 };
 }
 

common/config/tmtc/apid.h

@@ -1,18 +0,0 @@
-#ifndef FSFWCONFIG_TMTC_APID_H_
-#define FSFWCONFIG_TMTC_APID_H_
-
-#include <cstdint>
-
-/**
- * Application Process Definition: entity, uniquely identified by an
- * application process ID (APID), capable of generating telemetry source
- * packets and receiving telecommand packets
- *
- * EIVE APID: 0x65 / 101 / e
- * APID is a 11 bit number
- */
-namespace apid {
-static const uint16_t EIVE_OBSW = 0x65;
-}
-
-#endif /* FSFWCONFIG_TMTC_APID_H_ */

dummies/CMakeLists.txt

@@ -12,6 +12,7 @@ target_sources(
          AcuDummy.cpp
          PduDummy.cpp
          P60DockDummy.cpp
+         SaDeploymentDummy.cpp
          GpsDummy.cpp
          GyroAdisDummy.cpp
          GyroL3GD20Dummy.cpp

dummies/CoreControllerDummy.cpp

@@ -6,8 +6,7 @@
 #include <cmath>
 #include <cstdlib>
 
-CoreControllerDummy::CoreControllerDummy(object_id_t objectId)
+CoreControllerDummy::CoreControllerDummy(object_id_t objectId) : ExtendedControllerBase(objectId) {}
-    : ExtendedControllerBase(objectId, objects::NO_OBJECT) {}
 
 ReturnValue_t CoreControllerDummy::initialize() {
   static bool done = false;

dummies/ImtqDummy.cpp

@@ -1,6 +1,6 @@
 #include "ImtqDummy.h"
 
-#include <mission/devices/devicedefinitions/IMTQHandlerDefinitions.h>
+#include <mission/devices/devicedefinitions/imtqHandlerDefinitions.h>
 
 ImtqDummy::ImtqDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
     : DeviceHandlerBase(objectId, comif, comCookie) {}

dummies/SaDeploymentDummy.cpp

@@ -0,0 +1,7 @@
+#include "SaDeploymentDummy.h"
+
+SaDeplDummy::SaDeplDummy(object_id_t objectId) : SystemObject(objectId) {}
+
+SaDeplDummy::~SaDeplDummy() = default;
+
+ReturnValue_t SaDeplDummy::performOperation(uint8_t opCode) { return returnvalue::OK; }

dummies/SaDeploymentDummy.h

@@ -0,0 +1,19 @@
+
+#ifndef DUMMIES_SADEPLOYMENT_H_
+#define DUMMIES_SADEPLOYMENT_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+#include "SaDeploymentDummy.h"
+
+class SaDeplDummy : public SystemObject, public ExecutableObjectIF {
+ public:
+  SaDeplDummy(object_id_t objectId);
+  virtual ~SaDeplDummy();
+
+  ReturnValue_t performOperation(uint8_t opCode) override;
+
+ protected:
+};
+
+#endif /* DUMMIES_SADEPLOYMENT_H_ */

dummies/SusDummy.cpp

@@ -5,8 +5,7 @@
 #include <cmath>
 #include <cstdlib>
 
-SusDummy::SusDummy()
+SusDummy::SusDummy() : ExtendedControllerBase(objects::SUS_0_N_LOC_XFYFZM_PT_XF), susSet(this) {
-    : ExtendedControllerBase(objects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::NO_OBJECT), susSet(this) {
   ObjectManager::instance()->insert(objects::SUS_6_R_LOC_XFYBZM_PT_XF, this);
   ObjectManager::instance()->insert(objects::SUS_1_N_LOC_XBYFZM_PT_XB, this);
   ObjectManager::instance()->insert(objects::SUS_7_R_LOC_XBYBZM_PT_XB, this);

dummies/TemperatureSensorsDummy.cpp

@@ -6,7 +6,7 @@
 #include <cstdlib>
 
 TemperatureSensorsDummy::TemperatureSensorsDummy()
-    : ExtendedControllerBase(objects::RTD_0_IC3_PLOC_HEATSPREADER, objects::NO_OBJECT),
+    : ExtendedControllerBase(objects::RTD_0_IC3_PLOC_HEATSPREADER),
       max31865Set(this, MAX31865::MAX31865_SET_ID) {
   ObjectManager::instance()->insert(objects::RTD_1_IC4_PLOC_MISSIONBOARD, this);
   ObjectManager::instance()->insert(objects::RTD_2_IC5_4K_CAMERA, this);

dummies/helpers.cpp

@@ -13,9 +13,11 @@
 #include <dummies/PduDummy.h>
 #include <dummies/PlPcduDummy.h>
 #include <dummies/RwDummy.h>
+#include <dummies/SaDeploymentDummy.h>
 #include <dummies/StarTrackerDummy.h>
 #include <dummies/SusDummy.h>
 #include <dummies/SyrlinksDummy.h>
+#include <dummies/TemperatureSensorsDummy.h>
 
 #include "helpers.h"
 
@@ -28,13 +30,18 @@ void dummy::createDummies(DummyCfg cfg) {
   if (cfg.addCoreCtrlCfg) {
     new CoreControllerDummy(objects::CORE_CONTROLLER);
   }
-
+  if (cfg.addRtdComIFDummy) {
+    new ComIFDummy(objects::SPI_RTD_COM_IF);
+  }
   new RwDummy(objects::RW1, objects::DUMMY_COM_IF, comCookieDummy);
   new RwDummy(objects::RW2, objects::DUMMY_COM_IF, comCookieDummy);
   new RwDummy(objects::RW3, objects::DUMMY_COM_IF, comCookieDummy);
   new RwDummy(objects::RW4, objects::DUMMY_COM_IF, comCookieDummy);
+  new SaDeplDummy(objects::SOLAR_ARRAY_DEPL_HANDLER);
   new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
+  if (cfg.addSyrlinksDummies) {
     new SyrlinksDummy(objects::SYRLINKS_HK_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  }
   new ImtqDummy(objects::IMTQ_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
   if (cfg.addPowerDummies) {
     new AcuDummy(objects::ACU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
@@ -58,5 +65,9 @@ void dummy::createDummies(DummyCfg cfg) {
   if (cfg.addSusDummies) {
     new SusDummy();
   }
+
+  if (cfg.addTempSensorDummies) {
+    new TemperatureSensorsDummy();
+  }
   new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
 }

dummies/helpers.h

@@ -5,8 +5,11 @@ namespace dummy {
 struct DummyCfg {
   bool addCoreCtrlCfg = true;
   bool addPowerDummies = true;
+  bool addSyrlinksDummies = true;
   bool addAcsBoardDummies = true;
   bool addSusDummies = true;
+  bool addTempSensorDummies = true;
+  bool addRtdComIFDummy = true;
 };
 
 void createDummies(DummyCfg cfg);

generators/bsp_q7s_events.csv

@@ -69,6 +69,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 7510;0x1d56;TRYING_RECOVERY;MEDIUM;;fsfw/src/fsfw/health/HasHealthIF.h
 7511;0x1d57;RECOVERY_STEP;MEDIUM;;fsfw/src/fsfw/health/HasHealthIF.h
 7512;0x1d58;RECOVERY_DONE;MEDIUM;;fsfw/src/fsfw/health/HasHealthIF.h
+7600;0x1db0;HANDLE_PACKET_FAILED;LOW;;fsfw/src/fsfw/tcdistribution/definitions.h
 7900;0x1edc;RF_AVAILABLE;INFO;A RF available signal was detected. P1: raw RFA state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7901;0x1edd;RF_LOST;INFO;A previously found RF available signal was lost. P1: raw RFA state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7902;0x1ede;BIT_LOCK;INFO;A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
@@ -79,6 +80,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 9100;0x238c;TC_DELETION_FAILED;MEDIUM;Deletion of a TC from the map failed. P1: First 32 bit of request ID, P2. Last 32 bit of Request ID;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 9700;0x25e4;TEST;INFO;;fsfw/src/fsfw/pus/Service17Test.h
 10600;0x2968;CHANGE_OF_SETUP_PARAMETER;LOW;;fsfw/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
+10800;0x2a30;STORE_ERROR;LOW;;fsfw/src/fsfw/cfdp/handler/defs.h
+10801;0x2a31;MSG_QUEUE_ERROR;LOW;;fsfw/src/fsfw/cfdp/handler/defs.h
+10802;0x2a32;SERIALIZATION_ERROR;LOW;;fsfw/src/fsfw/cfdp/handler/defs.h
 11300;0x2c24;SWITCH_CMD_SENT;INFO;Indicates that a FSFW object requested setting a switch P1: 1 if on was requested, 0 for off | P2: Switch Index;mission/devices/devicedefinitions/powerDefinitions.h
 11301;0x2c25;SWITCH_HAS_CHANGED;INFO;Indicated that a switch state has changed P1: New switch state, 1 for on, 0 for off | P2: Switch Index;mission/devices/devicedefinitions/powerDefinitions.h
 11302;0x2c26;SWITCHING_Q7S_DENIED;MEDIUM;;mission/devices/devicedefinitions/powerDefinitions.h
@@ -91,25 +95,29 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11405;0x2c8d;SWITCH_ALREADY_OFF;LOW;;mission/devices/HeaterHandler.h
 11406;0x2c8e;MAIN_SWITCH_TIMEOUT;MEDIUM;;mission/devices/HeaterHandler.h
 11407;0x2c8f;FAULTY_HEATER_WAS_ON;LOW;;mission/devices/HeaterHandler.h
-11500;0x2cec;MAIN_SWITCH_ON_TIMEOUT;LOW;;mission/devices/SolarArrayDeploymentHandler.h
+11500;0x2cec;BURN_PHASE_START;INFO;P1: Burn duration in milliseconds, P2: Dry run flag;mission/devices/SolarArrayDeploymentHandler.h
-11501;0x2ced;MAIN_SWITCH_OFF_TIMEOUT;LOW;;mission/devices/SolarArrayDeploymentHandler.h
+11501;0x2ced;BURN_PHASE_DONE;INFO;P1: Burn duration in milliseconds, P2: Dry run flag;mission/devices/SolarArrayDeploymentHandler.h
-11502;0x2cee;DEPLOYMENT_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
+11502;0x2cee;MAIN_SWITCH_ON_TIMEOUT;LOW;;mission/devices/SolarArrayDeploymentHandler.h
-11503;0x2cef;DEPL_SA1_GPIO_SWTICH_ON_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
+11503;0x2cef;MAIN_SWITCH_OFF_TIMEOUT;LOW;;mission/devices/SolarArrayDeploymentHandler.h
-11504;0x2cf0;DEPL_SA2_GPIO_SWTICH_ON_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
+11504;0x2cf0;DEPL_SA1_GPIO_SWTICH_ON_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
+11505;0x2cf1;DEPL_SA2_GPIO_SWTICH_ON_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
+11506;0x2cf2;DEPL_SA1_GPIO_SWTICH_OFF_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
+11507;0x2cf3;DEPL_SA2_GPIO_SWTICH_OFF_FAILED;HIGH;;mission/devices/SolarArrayDeploymentHandler.h
+11508;0x2cf4;AUTONOMOUS_DEPLOYMENT_COMPLETED;INFO;;mission/devices/SolarArrayDeploymentHandler.h
 11601;0x2d51;MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC crc failure in telemetry packet;linux/devices/ploc/PlocMPSoCHandler.h
 11602;0x2d52;ACK_FAILURE;LOW;PLOC receive acknowledgment failure report P1: Command Id which leads the acknowledgment failure report P2: The status field inserted by the MPSoC into the data field;linux/devices/ploc/PlocMPSoCHandler.h
 11603;0x2d53;EXE_FAILURE;LOW;PLOC receive execution failure report P1: Command Id which leads the execution failure report P2: The status field inserted by the MPSoC into the data field;linux/devices/ploc/PlocMPSoCHandler.h
 11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/devices/ploc/PlocMPSoCHandler.h
 11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/devices/ploc/PlocMPSoCHandler.h
 11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/devices/ploc/PlocMPSoCHandler.h
-11701;0x2db5;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h
+11701;0x2db5;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/ImtqHandler.h
-11702;0x2db6;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h
+11702;0x2db6;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/ImtqHandler.h
-11703;0x2db7;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/IMTQHandler.h
+11703;0x2db7;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/devices/ImtqHandler.h
-11704;0x2db8;SELF_TEST_PWM_FAILURE;LOW;Get self test result returns PWM failure which concerns the coil actuation. 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
+11704;0x2db8;SELF_TEST_PWM_FAILURE;LOW;Get self test result returns PWM failure which concerns the coil actuation. 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
-11705;0x2db9;SELF_TEST_TC_FAILURE;LOW;Get self test result returns TC failure (system 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
+11705;0x2db9;SELF_TEST_TC_FAILURE;LOW;Get self test result returns TC failure (system 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
-11706;0x2dba;SELF_TEST_MTM_RANGE_FAILURE;LOW;Get self test result returns failure that MTM values were outside of the expected range. 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
+11706;0x2dba;SELF_TEST_MTM_RANGE_FAILURE;LOW;Get self test result returns failure that MTM values were outside of the expected range. 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
-11707;0x2dbb;SELF_TEST_COIL_CURRENT_FAILURE;LOW;Get self test result returns failure indicating that the coil current was outside of the expected range 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
+11707;0x2dbb;SELF_TEST_COIL_CURRENT_FAILURE;LOW;Get self test result returns failure indicating that the coil current was outside of the expected range 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
-11708;0x2dbc;INVALID_ERROR_BYTE;LOW;Received invalid error byte. This indicates an error of the communication link between IMTQ and OBC.;mission/devices/IMTQHandler.h
+11708;0x2dbc;INVALID_ERROR_BYTE;LOW;Received invalid error byte. This indicates an error of the communication link between IMTQ and OBC.;mission/devices/ImtqHandler.h
 11801;0x2e19;ERROR_STATE;HIGH;Reaction wheel signals an error state;mission/devices/devicedefinitions/RwDefinitions.h
 11802;0x2e1a;RESET_OCCURED;LOW;;mission/devices/devicedefinitions/RwDefinitions.h
 11901;0x2e7d;BOOTING_FIRMWARE_FAILED;LOW;Failed to boot firmware;linux/devices/startracker/StarTrackerHandler.h
@@ -119,17 +127,18 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12003;0x2ee3;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report P1: ID of command for which the execution failed P2: Status code sent by the supervisor handler;linux/devices/ploc/PlocSupervisorHandler.h
 12004;0x2ee4;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/devices/ploc/PlocSupervisorHandler.h
 12005;0x2ee5;SUPV_MPSOC_SHUWDOWN_BUILD_FAILED;LOW;Failed to build the command to shutdown the MPSoC;linux/devices/ploc/PlocSupervisorHandler.h
-12100;0x2f44;SANITIZATION_FAILED;LOW;;bsp_q7s/memory/SdCardManager.h
+12100;0x2f44;SANITIZATION_FAILED;LOW;;bsp_q7s/fs/SdCardManager.h
-12101;0x2f45;MOUNTED_SD_CARD;INFO;;bsp_q7s/memory/SdCardManager.h
+12101;0x2f45;MOUNTED_SD_CARD;INFO;;bsp_q7s/fs/SdCardManager.h
 12300;0x300c;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
 12301;0x300d;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
 12302;0x300e;MRAM_DUMP_FINISHED;LOW;MRAM dump finished successfully;linux/devices/ploc/PlocMemoryDumper.h
-12401;0x3071;INVALID_TC_FRAME;HIGH;;linux/obc/PdecHandler.h
+12401;0x3071;INVALID_TC_FRAME;HIGH;;linux/ipcore/PdecHandler.h
-12402;0x3072;INVALID_FAR;HIGH;Read invalid FAR from PDEC after startup;linux/obc/PdecHandler.h
+12402;0x3072;INVALID_FAR;HIGH;Read invalid FAR from PDEC after startup;linux/ipcore/PdecHandler.h
-12403;0x3073;CARRIER_LOCK;INFO;Carrier lock detected;linux/obc/PdecHandler.h
+12403;0x3073;CARRIER_LOCK;INFO;Carrier lock detected;linux/ipcore/PdecHandler.h
-12404;0x3074;BIT_LOCK_PDEC;INFO;Bit lock detected (data valid);linux/obc/PdecHandler.h
+12404;0x3074;BIT_LOCK_PDEC;INFO;Bit lock detected (data valid);linux/ipcore/PdecHandler.h
-12405;0x3075;LOST_CARRIER_LOCK_PDEC;INFO;Lost carrier lock;linux/obc/PdecHandler.h
+12405;0x3075;LOST_CARRIER_LOCK_PDEC;INFO;Lost carrier lock;linux/ipcore/PdecHandler.h
-12406;0x3076;LOST_BIT_LOCK_PDEC;INFO;Lost bit lock;linux/obc/PdecHandler.h
+12406;0x3076;LOST_BIT_LOCK_PDEC;INFO;Lost bit lock;linux/ipcore/PdecHandler.h
+12407;0x3077;POLL_ERROR_PDEC;MEDIUM;;linux/ipcore/PdecHandler.h
 12500;0x30d4;IMAGE_UPLOAD_FAILED;LOW;Image upload failed;linux/devices/startracker/StrHelper.h
 12501;0x30d5;IMAGE_DOWNLOAD_FAILED;LOW;Image download failed;linux/devices/startracker/StrHelper.h
 12502;0x30d6;IMAGE_UPLOAD_SUCCESSFUL;LOW;Uploading image to star tracker was successfulop;linux/devices/startracker/StrHelper.h
@@ -173,15 +182,15 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12709;0x31a5;I_MPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
 12710;0x31a6;U_HPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
 12711;0x31a7;I_HPA_OUT_OF_BOUNDS;MEDIUM;P1: 0 -> too low, 1 -> too high P2: Float value;mission/devices/PayloadPcduHandler.h
-12800;0x3200;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/AcsBoardAssembly.h
+12800;0x3200;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/objects/AcsBoardAssembly.h
-12801;0x3201;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/AcsBoardAssembly.h
+12801;0x3201;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/objects/AcsBoardAssembly.h
-12802;0x3202;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/AcsBoardAssembly.h
+12802;0x3202;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/objects/AcsBoardAssembly.h
-12803;0x3203;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
+12803;0x3203;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/objects/AcsBoardAssembly.h
-12900;0x3264;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/SusAssembly.h
+12900;0x3264;TRANSITION_OTHER_SIDE_FAILED;HIGH;;mission/system/objects/SusAssembly.h
-12901;0x3265;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/SusAssembly.h
+12901;0x3265;NOT_ENOUGH_DEVICES_DUAL_MODE;HIGH;;mission/system/objects/SusAssembly.h
-12902;0x3266;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/SusAssembly.h
+12902;0x3266;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;;mission/system/objects/SusAssembly.h
-12903;0x3267;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/SusAssembly.h
+12903;0x3267;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/objects/SusAssembly.h
-13000;0x32c8;CHILDREN_LOST_MODE;MEDIUM;;mission/system/TcsBoardAssembly.h
+13000;0x32c8;CHILDREN_LOST_MODE;MEDIUM;;mission/system/objects/TcsBoardAssembly.h
 13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: Old fix. P2: New fix 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;mission/devices/devicedefinitions/GPSDefinitions.h
 13200;0x3390;P60_BOOT_COUNT;INFO;P60 boot count is broadcasted once at SW startup. P1: Boot count;mission/devices/P60DockHandler.h
 13201;0x3391;BATT_MODE;INFO;Battery mode is broadcasted at startup. P1: Mode;mission/devices/P60DockHandler.h
@@ -215,3 +224,12 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 13701;0x3585;REBOOT_SW;MEDIUM; Software reboot occurred. Can also be a systemd reboot. P1: Current Chip, P2: Current Copy;bsp_q7s/core/CoreController.h
 13702;0x3586;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
 13703;0x3587;REBOOT_HW;MEDIUM;;bsp_q7s/core/CoreController.h
+13704;0x3588;NO_SD_CARD_ACTIVE;HIGH;No SD card was active. Core controller will attempt to re-initialize a SD card.;bsp_q7s/core/CoreController.h
+13800;0x35e8;MISSING_PACKET;LOW;;mission/devices/devicedefinitions/ScexDefinitions.h
+13801;0x35e9;EXPERIMENT_TIMEDOUT;LOW;;mission/devices/devicedefinitions/ScexDefinitions.h
+13802;0x35ea;MULTI_PACKET_COMMAND_DONE;INFO;;mission/devices/devicedefinitions/ScexDefinitions.h
+13901;0x364d;SET_CONFIGFILEVALUE_FAILED;MEDIUM;;mission/utility/GlobalConfigHandler.h
+13902;0x364e;GET_CONFIGFILEVALUE_FAILED;MEDIUM;;mission/utility/GlobalConfigHandler.h
+13903;0x364f;INSERT_CONFIGFILEVALUE_FAILED;MEDIUM;;mission/utility/GlobalConfigHandler.h
+13904;0x3650;WRITE_CONFIGFILE_FAILED;MEDIUM;;mission/utility/GlobalConfigHandler.h
+13905;0x3651;READ_CONFIGFILE_FAILED;MEDIUM;;mission/utility/GlobalConfigHandler.h

generators/bsp_q7s_objects.csv

@@ -1,6 +1,7 @@
 0x00005060;P60DOCK_TEST_TASK
 0x43000002;ACS_CONTROLLER
 0x43000003;CORE_CONTROLLER
+0x43000006;GLOBAL_JSON_CFG
 0x43400001;THERMAL_CONTROLLER
 0x44120006;MGM_0_LIS3_HANDLER
 0x44120010;GYRO_0_ADIS_HANDLER
@@ -46,6 +47,7 @@
 0x44330015;PLOC_MPSOC_HANDLER
 0x44330016;PLOC_SUPERVISOR_HANDLER
 0x44330017;PLOC_SUPERVISOR_HELPER
+0x44330032;SCEX
 0x444100A2;SOLAR_ARRAY_DEPL_HANDLER
 0x444100A4;HEATER_HANDLER
 0x44420004;TMP1075_HANDLER_1
@@ -69,6 +71,7 @@
 0x445300A3;SYRLINKS_HK_HANDLER
 0x49000000;ARDUINO_COM_IF
 0x49010005;GPIO_IF
+0x49010006;SCEX_UART_READER
 0x49020004;SPI_MAIN_COM_IF
 0x49020005;SPI_RW_COM_IF
 0x49020006;SPI_RTD_COM_IF
@@ -128,6 +131,12 @@
 0x73000002;SUS_BOARD_ASS
 0x73000003;TCS_BOARD_ASS
 0x73000004;RW_ASS
+0x73000005;CFDP_HANDLER
+0x73000006;CFDP_DISTRIBUTOR
 0x73000100;TM_FUNNEL
+0x73000101;PUS_TM_FUNNEL
+0x73000102;CFDP_TM_FUNNEL
+0x73010000;EIVE_SYSTEM
+0x73010001;ACS_SUBSYSTEM
 0x73500000;CCSDS_IP_CORE_BRIDGE
 0xFFFFFFFF;NO_OBJECT

generators/bsp_q7s_returnvalues.csv

@@ -1,14 +1,13 @@
 Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
-0x0000;OK;System-wide code for ok.;0;HasReturnvaluesIF;fsfw/returnvalues/HasReturnvaluesIF.h
+0x0000;OK;System-wide code for ok.;0;HasReturnvaluesIF;fsfw/returnvalues/returnvalue.h
-0x0001;Failed;Unspecified system-wide code for failed.;1;HasReturnvaluesIF;fsfw/returnvalues/HasReturnvaluesIF.h
+0x0001;Failed;Unspecified system-wide code for failed.;1;HasReturnvaluesIF;fsfw/returnvalues/returnvalue.h
-0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NVMParameterBase.h
+0x60a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/tmtc/CcsdsIpCoreHandler.h
-0x58a0;SUSS_ErrorUnlockMutex;;160;SUS_HANDLER;mission/devices/SusHandler.h
+0x5d00;GOMS_PacketTooLong;;0;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x58a1;SUSS_ErrorLockMutex;;161;SUS_HANDLER;mission/devices/SusHandler.h
+0x5d01;GOMS_InvalidTableId;;1;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x66a0;SADPL_CommandNotSupported;;160;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x5d02;GOMS_InvalidAddress;;2;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x66a1;SADPL_DeploymentAlreadyExecuting;;161;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x5d03;GOMS_InvalidParamSize;;3;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x66a2;SADPL_MainSwitchTimeoutFailure;;162;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x5d04;GOMS_InvalidPayloadSize;;4;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x66a3;SADPL_SwitchingDeplSa1Failed;;163;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x5d05;GOMS_UnknownReplyId;;5;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x66a4;SADPL_SwitchingDeplSa2Failed;;164;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
 0x52b0;RWHA_SpiWriteFailure;;176;RW_HANDLER;mission/devices/RwHandler.h
 0x52b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/devices/RwHandler.h
 0x52b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/devices/RwHandler.h
@@ -21,20 +20,21 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x52a2;RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;RW_HANDLER;mission/devices/RwHandler.h
 0x52a3;RWHA_ExecutionFailed;Command execution failed;163;RW_HANDLER;mission/devices/RwHandler.h
 0x52a4;RWHA_CrcError;Reaction wheel reply has invalid crc;164;RW_HANDLER;mission/devices/RwHandler.h
-0x5d00;GOMS_PacketTooLong;;0;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x4fa1;HEATER_CommandNotSupported;;161;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x5d01;GOMS_InvalidTableId;;1;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x4fa2;HEATER_InitFailed;;162;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x5d02;GOMS_InvalidAddress;;2;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x4fa3;HEATER_InvalidSwitchNr;;163;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x5d03;GOMS_InvalidParamSize;;3;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x4fa4;HEATER_MainSwitchSetTimeout;;164;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x5d04;GOMS_InvalidPayloadSize;;4;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x4fa5;HEATER_CommandAlreadyWaiting;;165;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x5d05;GOMS_UnknownReplyId;;5;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x58a0;SUSS_ErrorUnlockMutex;;160;SUS_HANDLER;mission/devices/SusHandler.h
-0x51a0;IMTQ_InvalidCommandCode;;160;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x58a1;SUSS_ErrorLockMutex;;161;SUS_HANDLER;mission/devices/SusHandler.h
-0x51a1;IMTQ_ParameterMissing;;161;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x51a0;IMTQ_InvalidCommandCode;;160;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a2;IMTQ_ParameterInvalid;;162;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x51a1;IMTQ_ParameterMissing;;161;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a3;IMTQ_CcUnavailable;;163;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x51a2;IMTQ_ParameterInvalid;;162;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a4;IMTQ_InternalProcessingError;;164;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x51a3;IMTQ_CcUnavailable;;163;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a5;IMTQ_RejectedWithoutReason;;165;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x51a4;IMTQ_InternalProcessingError;;164;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a6;IMTQ_CmdErrUnknown;;166;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x51a5;IMTQ_RejectedWithoutReason;;165;IMTQ_HANDLER;mission/devices/ImtqHandler.h
-0x51a7;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.;167;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x51a6;IMTQ_CmdErrUnknown;;166;IMTQ_HANDLER;mission/devices/ImtqHandler.h
+0x51a7;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.;167;IMTQ_HANDLER;mission/devices/ImtqHandler.h
 0x50a0;SYRLINKS_CrcFailure;;160;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
 0x50a1;SYRLINKS_UartFraminOrParityErrorAck;;161;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
 0x50a2;SYRLINKS_BadCharacterAck;;162;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
@@ -44,126 +44,130 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x50a6;SYRLINKS_BadCrcAck;;166;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
 0x50a7;SYRLINKS_ReplyWrongSize;;167;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
 0x50a8;SYRLINKS_MissingStartFrameCharacter;;168;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x4fa1;HEATER_CommandNotSupported;;161;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x66a0;SADPL_CommandNotSupported;;160;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x4fa2;HEATER_InitFailed;;162;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x66a1;SADPL_DeploymentAlreadyExecuting;;161;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x4fa3;HEATER_InvalidSwitchNr;;163;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x66a2;SADPL_MainSwitchTimeoutFailure;;162;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x4fa4;HEATER_MainSwitchSetTimeout;;164;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x66a3;SADPL_SwitchingDeplSa1Failed;;163;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x4fa5;HEATER_CommandAlreadyWaiting;;165;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x66a4;SADPL_SwitchingDeplSa2Failed;;164;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x60a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/tmtc/CCSDSHandler.h
+0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NVMParameterBase.h
-0x4500;HSPI_OpeningFileFailed;;0;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
+0x2c01;CCS_BcIsSetVrCommand;;1;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4501;HSPI_FullDuplexTransferFailed;;1;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
+0x2c02;CCS_BcIsUnlockCommand;;2;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4502;HSPI_HalfDuplexTransferFailed;;2;HAL_SPI;fsfw/src/fsfw_hal/linux/spi/SpiComIF.h
+0x2cb0;CCS_BcIllegalCommand;;176;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4801;HGIO_UnknownGpioId;;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x2cb1;CCS_BoardReadingNotFinished;;177;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4802;HGIO_DriveGpioFailure;;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x2cf0;CCS_NsPositiveW;;240;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4803;HGIO_GpioTypeFailure;;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x2cf1;CCS_NsNegativeW;;241;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4804;HGIO_GpioInvalidInstance;;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x2cf2;CCS_NsLockout;;242;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4805;HGIO_GpioDuplicateDetected;;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x2cf3;CCS_FarmInLockout;;243;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4806;HGIO_GpioInitFailed;;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x2cf4;CCS_FarmInWait;;244;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4807;HGIO_GpioGetValueFailed;;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x2ce0;CCS_WrongSymbol;;224;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4601;HURT_UartReadFailure;;1;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
+0x2ce1;CCS_DoubleStart;;225;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4602;HURT_UartReadSizeMissmatch;;2;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
+0x2ce2;CCS_StartSymbolMissed;;226;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4603;HURT_UartRxBufferTooSmall;;3;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
+0x2ce3;CCS_EndWithoutStart;;227;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4400;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x2ce4;CCS_TooLarge;;228;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4401;UXOS_CommandPending;Command is pending. This will also be returned if the user tries to load another command but a command is still pending;1;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x2ce5;CCS_TooShort;;229;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4402;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x2ce6;CCS_WrongTfVersion;;230;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x2ce7;CCS_WrongSpacecraftId;;231;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x2ce8;CCS_NoValidFrameType;;232;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x4406;UXOS_PcloseCallError;;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x2ce9;CCS_CrcFailed;;233;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2801;SM_DataTooLarge;;1;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2cea;CCS_VcNotFound;;234;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2802;SM_DataStorageFull;;2;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2ceb;CCS_ForwardingFailed;;235;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2803;SM_IllegalStorageId;;3;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2cec;CCS_ContentTooLarge;;236;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2804;SM_DataDoesNotExist;;4;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2ced;CCS_ResidualData;;237;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2805;SM_IllegalAddress;;5;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2cee;CCS_DataCorrupted;;238;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2806;SM_PoolTooLarge;;6;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2cef;CCS_IllegalSegmentationFlag;;239;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x0601;PP_DoItMyself;;1;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x2cd0;CCS_IllegalFlagCombination;;208;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x0602;PP_PointsToVariable;;2;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x2cd1;CCS_ShorterThanHeader;;209;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x0603;PP_PointsToMemory;;3;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x2cd2;CCS_TooShortBlockedPacket;;210;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x0604;PP_ActivityCompleted;;4;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x2cd3;CCS_TooShortMapExtraction;;211;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x0605;PP_PointsToVectorUint8;;5;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x3b00;SPH_ConnBroken;;0;SEMAPHORE_IF;fsfw/src/fsfw/osal/common/TcpTmTcServer.h
-0x0606;PP_PointsToVectorUint16;;6;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x2a01;IEC_NoConfigurationTable;;1;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x0607;PP_PointsToVectorUint32;;7;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x2a02;IEC_NoCpuTable;;2;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x0608;PP_PointsToVectorFloat;;8;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x2a03;IEC_InvalidWorkspaceAddress;;3;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x06a0;PP_DumpNotSupported;;160;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x2a04;IEC_TooLittleWorkspace;;4;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x06e0;PP_InvalidSize;;224;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x2a05;IEC_WorkspaceAllocation;;5;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x06e1;PP_InvalidAddress;;225;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x2a06;IEC_InterruptStackTooSmall;;6;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x06e2;PP_InvalidContent;;226;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x2a07;IEC_ThreadExitted;;7;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x06e3;PP_UnalignedAccess;;227;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x2a08;IEC_InconsistentMpInformation;;8;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x06e4;PP_WriteProtected;;228;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x2a09;IEC_InvalidNode;;9;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x4300;FILS_GenericFileError;;0;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x2a0a;IEC_NoMpci;;10;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x4301;FILS_IsBusy;;1;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x2a0b;IEC_BadPacket;;11;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x4302;FILS_InvalidParameters;;2;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x2a0c;IEC_OutOfPackets;;12;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x4305;FILS_FileDoesNotExist;;5;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x2a0d;IEC_OutOfGlobalObjects;;13;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x4306;FILS_FileAlreadyExists;;6;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x2a0e;IEC_OutOfProxies;;14;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x4307;FILS_FileLocked;;7;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x2a0f;IEC_InvalidGlobalId;;15;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x430a;FILS_DirectoryDoesNotExist;;10;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x2a10;IEC_BadStackHook;;16;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x430b;FILS_DirectoryAlreadyExists;;11;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x2a11;IEC_BadAttributes;;17;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x430c;FILS_DirectoryNotEmpty;;12;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x2a12;IEC_ImplementationKeyCreateInconsistency;;18;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x430f;FILS_SequencePacketMissingWrite;;15;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x2a13;IEC_ImplementationBlockingOperationCancel;;19;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x4310;FILS_SequencePacketMissingRead;;16;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x2a14;IEC_MutexObtainFromBadState;;20;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x13e0;MH_UnknownCmd;;224;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
+0x2a15;IEC_UnlimitedAndMaximumIs0;;21;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x13e1;MH_InvalidAddress;;225;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
-0x13e2;MH_InvalidSize;;226;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
-0x13e3;MH_StateMismatch;;227;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
-0x38a1;SGP4_InvalidEccentricity;;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a2;SGP4_InvalidMeanMotion;;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a3;SGP4_InvalidPerturbationElements;;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a4;SGP4_InvalidSemiLatusRectum;;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a5;SGP4_InvalidEpochElements;;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38a6;SGP4_SatelliteHasDecayed;;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38b1;SGP4_TleTooOld;;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x38b2;SGP4_TleNotInitialized;;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x1101;AL_Full;;1;ARRAY_LIST;fsfw/src/fsfw/container/ArrayList.h
-0x1501;FM_KeyAlreadyExists;;1;FIXED_MAP;fsfw/src/fsfw/container/FixedMap.h
-0x1502;FM_MapFull;;2;FIXED_MAP;fsfw/src/fsfw/container/FixedMap.h
-0x1503;FM_KeyDoesNotExist;;3;FIXED_MAP;fsfw/src/fsfw/container/FixedMap.h
-0x1801;FF_Full;;1;FIFO_CLASS;fsfw/src/fsfw/container/FIFOBase.h
-0x1802;FF_Empty;;2;FIFO_CLASS;fsfw/src/fsfw/container/FIFOBase.h
-0x1601;FMM_MapFull;;1;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
-0x1602;FMM_KeyDoesNotExist;;2;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
-0x3901;MUX_NotEnoughResources;;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3902;MUX_InsufficientMemory;;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3903;MUX_NoPrivilege;;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3904;MUX_WrongAttributeSetting;;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3905;MUX_MutexAlreadyLocked;;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3906;MUX_MutexNotFound;;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3907;MUX_MutexMaxLocks;;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3908;MUX_CurrThreadAlreadyOwnsMutex;;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3909;MUX_CurrThreadDoesNotOwnMutex;;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x390a;MUX_MutexTimeout;;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x390b;MUX_MutexInvalidId;;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x390c;MUX_MutexDestroyedWhileWaiting;;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3a01;MQI_Empty;;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x0f01;CM_UnknownCommand;;1;COMMAND_MESSAGE;fsfw/src/fsfw/ipc/CommandMessageIF.h
 0x0e01;HM_InvalidMode;;1;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
 0x0e02;HM_TransNotAllowed;;2;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
 0x0e03;HM_InTransition;;3;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
 0x0e04;HM_InvalidSubmode;;4;HAS_MODES_IF;fsfw/src/fsfw/modes/HasModesIF.h
-0x0c02;MS_InvalidEntry;;2;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
+0x2e01;HPA_InvalidIdentifierId;;1;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x0c03;MS_TooManyElements;;3;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
+0x2e02;HPA_InvalidDomainId;;2;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x0c04;MS_CantStoreEmpty;;4;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
+0x2e03;HPA_InvalidValue;;3;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x0b01;SB_ChildNotFound;;1;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x2e05;HPA_ReadOnly;;5;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x0b02;SB_ChildInfoUpdated;;2;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x2d01;PAW_UnknownDatatype;;1;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x0b03;SB_ChildDoesntHaveModes;;3;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x2d02;PAW_DatatypeMissmatch;;2;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x0b04;SB_CouldNotInsertChild;;4;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x2d03;PAW_Readonly;;3;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x0b05;SB_TableContainsInvalidObjectId;;5;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x2d04;PAW_TooBig;;4;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x0d01;SS_SequenceAlreadyExists;;1;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x2d05;PAW_SourceNotSet;;5;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x0d02;SS_TableAlreadyExists;;2;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x2d06;PAW_OutOfBounds;;6;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x0d03;SS_TableDoesNotExist;;3;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x2d07;PAW_NotSet;;7;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x0d04;SS_TableOrSequenceLengthInvalid;;4;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x2d08;PAW_ColumnOrRowsZero;;8;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x0d05;SS_SequenceDoesNotExist;;5;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x3201;CF_ObjectHasNoFunctions;;1;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
-0x0d06;SS_TableContainsInvalidObjectId;;6;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x3202;CF_AlreadyCommanding;;2;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
-0x0d07;SS_FallbackSequenceDoesNotExist;;7;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x3301;HF_IsBusy;;1;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x0d08;SS_NoTargetTable;;8;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x3302;HF_InvalidParameters;;2;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x0d09;SS_SequenceOrTableTooLong;;9;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x3303;HF_ExecutionFinished;;3;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x0d0b;SS_IsFallbackSequence;;11;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x3304;HF_InvalidActionId;;4;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x0d0c;SS_AccessDenied;;12;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0201;OM_InsertionFailed;;1;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x0d0e;SS_TableInUse;;14;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0202;OM_NotFound;;2;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x0da1;SS_TargetTableNotReached;;161;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0203;OM_ChildInitFailed;;3;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x0da2;SS_TableCheckFailed;;162;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0204;OM_InternalErrReporterUninit;;4;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x2501;EV_ListenerNotFound;;1;EVENT_MANAGER_IF;fsfw/src/fsfw/events/EventManagerIF.h
+0x2600;FDI_YourFault;;0;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
+0x2601;FDI_MyFault;;1;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
+0x2602;FDI_ConfirmLater;;2;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
+0x2201;TMF_Busy;;1;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2202;TMF_LastPacketFound;;2;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2203;TMF_StopFetch;;3;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2204;TMF_Timeout;;4;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2205;TMF_TmChannelFull;;5;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2206;TMF_NotStored;;6;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2207;TMF_AllDeleted;;7;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2208;TMF_InvalidData;;8;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2209;TMF_NotReady;;9;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2101;TMB_Busy;;1;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2102;TMB_Full;;2;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2103;TMB_Empty;;3;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2104;TMB_NullRequested;;4;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2105;TMB_TooLarge;;5;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2106;TMB_NotReady;;6;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2107;TMB_DumpError;;7;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2108;TMB_CrcError;;8;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2109;TMB_Timeout;;9;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210a;TMB_IdlePacketFound;;10;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210b;TMB_TelecommandFound;;11;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210c;TMB_NoPusATm;;12;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210d;TMB_TooSmall;;13;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210e;TMB_BlockNotFound;;14;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x210f;TMB_InvalidRequest;;15;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x1c01;TCD_PacketLost;;1;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
+0x1c02;TCD_DestinationNotFound;;2;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
+0x1c03;TCD_ServiceIdAlreadyExists;;3;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributorBase.h
+0x1b00;TCC_NoDestinationFound;;0;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b01;TCC_InvalidCcsdsVersion;;1;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b02;TCC_InvalidApid;;2;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b03;TCC_InvalidPacketType;;3;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b04;TCC_InvalidSecHeaderField;;4;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b05;TCC_IncorrectPrimaryHeader;;5;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b07;TCC_IncompletePacket;;7;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b08;TCC_InvalidPusVersion;;8;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b09;TCC_IncorrectChecksum;;9;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b0a;TCC_IllegalPacketSubtype;;10;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1b0b;TCC_IncorrectSecondaryHeader;;11;TMTC_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/definitions.h
 0x04e1;RMP_CommandNoDescriptorsAvailable;;225;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
 0x04e2;RMP_CommandBufferFull;;226;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
 0x04e3;RMP_CommandChannelOutOfRange;;227;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
@@ -204,9 +208,95 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x040a;RMP_ReplyCommandNotImplementedOrNotAuthorised;;10;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
 0x040b;RMP_ReplyRmwDataLengthError;;11;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
 0x040c;RMP_ReplyInvalidTargetLogicalAddress;;12;RMAP_CHANNEL;fsfw/src/fsfw/rmap/RMAP.h
-0x1401;SE_BufferTooShort;;1;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
+0x2801;SM_DataTooLarge;;1;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x1402;SE_StreamTooShort;;2;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
+0x2802;SM_DataStorageFull;;2;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
-0x1403;SE_TooManyElements;;3;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
+0x2803;SM_IllegalStorageId;;3;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2804;SM_DataDoesNotExist;;4;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2805;SM_IllegalAddress;;5;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x2806;SM_PoolTooLarge;;6;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x38a1;SGP4_InvalidEccentricity;;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a2;SGP4_InvalidMeanMotion;;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a3;SGP4_InvalidPerturbationElements;;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a4;SGP4_InvalidSemiLatusRectum;;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a5;SGP4_InvalidEpochElements;;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38a6;SGP4_SatelliteHasDecayed;;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38b1;SGP4_TleTooOld;;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x38b2;SGP4_TleNotInitialized;;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x2401;MT_NoPacketFound;;1;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/DleParser.h
+0x2402;MT_PossiblePacketLoss;;2;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/DleParser.h
+0x2403;MT_NoMatch;;3;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2404;MT_Full;;4;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2405;MT_NewNodeCreated;;5;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x3f01;DLEE_StreamTooShort;;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x3f02;DLEE_DecodingError;;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x2f01;ASC_TooLongForTargetType;;1;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x2f02;ASC_InvalidCharacters;;2;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x2f03;ASC_BufferTooSmall;;3;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x0f01;CM_UnknownCommand;;1;COMMAND_MESSAGE;fsfw/src/fsfw/ipc/CommandMessageIF.h
+0x3a01;MQI_Empty;;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3a02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3a03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3a04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3901;MUX_NotEnoughResources;;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3902;MUX_InsufficientMemory;;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3903;MUX_NoPrivilege;;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3904;MUX_WrongAttributeSetting;;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3905;MUX_MutexAlreadyLocked;;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3906;MUX_MutexNotFound;;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3907;MUX_MutexMaxLocks;;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3908;MUX_CurrThreadAlreadyOwnsMutex;;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3909;MUX_CurrThreadDoesNotOwnMutex;;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x390a;MUX_MutexTimeout;;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x390b;MUX_MutexInvalidId;;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x390c;MUX_MutexDestroyedWhileWaiting;;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3b01;SPH_SemaphoreTimeout;;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3b02;SPH_SemaphoreNotOwned;;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3b03;SPH_SemaphoreInvalid;;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x1e00;PUS_InvalidPusVersion;;0;PUS_IF;fsfw/src/fsfw/tmtcpacket/pus/PusIF.h
+0x1e01;PUS_InvalidCrc16;;1;PUS_IF;fsfw/src/fsfw/tmtcpacket/pus/PusIF.h
+0x3601;CFDP_InvalidTlvType;;1;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3602;CFDP_InvalidDirectiveField;;2;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3603;CFDP_InvalidPduDatafieldLen;;3;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3604;CFDP_InvalidAckDirectiveFields;;4;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3605;CFDP_MetadataCantParseOptions;;5;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3606;CFDP_NakCantParseOptions;;6;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3607;CFDP_FinishedCantParseFsResponses;;7;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3608;CFDP_FilestoreRequiresSecondFile;;8;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3609;CFDP_FilestoreResponseCantParseFsMessage;;9;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x360a;CFDP_InvalidPduFormat;;10;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x2901;TC_InvalidTargetState;;1;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
+0x29f1;TC_AboveOperationalLimit;;241;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
+0x29f2;TC_BelowOperationalLimit;;242;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
+0x0c02;MS_InvalidEntry;;2;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
+0x0c03;MS_TooManyElements;;3;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
+0x0c04;MS_CantStoreEmpty;;4;MODE_STORE_IF;fsfw/src/fsfw/subsystem/modes/ModeStoreIF.h
+0x0d01;SS_SequenceAlreadyExists;;1;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d02;SS_TableAlreadyExists;;2;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d03;SS_TableDoesNotExist;;3;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d04;SS_TableOrSequenceLengthInvalid;;4;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d05;SS_SequenceDoesNotExist;;5;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d06;SS_TableContainsInvalidObjectId;;6;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d07;SS_FallbackSequenceDoesNotExist;;7;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d08;SS_NoTargetTable;;8;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d09;SS_SequenceOrTableTooLong;;9;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d0b;SS_IsFallbackSequence;;11;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d0c;SS_AccessDenied;;12;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0d0e;SS_TableInUse;;14;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0da1;SS_TargetTableNotReached;;161;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0da2;SS_TableCheckFailed;;162;SUBSYSTEM;fsfw/src/fsfw/subsystem/Subsystem.h
+0x0b01;SB_ChildNotFound;;1;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x0b02;SB_ChildInfoUpdated;;2;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x0b03;SB_ChildDoesntHaveModes;;3;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x0b04;SB_CouldNotInsertChild;;4;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x0b05;SB_TableContainsInvalidObjectId;;5;SUBSYSTEM_BASE;fsfw/src/fsfw/subsystem/SubsystemBase.h
+0x3e00;HKM_QueueOrDestinationInvalid;;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e01;HKM_WrongHkPacketType;;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e02;HKM_ReportingStatusUnchanged;;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e03;HKM_PeriodicHelperInvalid;;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e04;HKM_PoolobjectNotFound;;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3e05;HKM_DatasetNotFound;;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3c00;LPIF_PoolEntryNotFound;;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3c01;LPIF_PoolEntryTypeConflict;;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
 0x3da0;PVA_InvalidReadWriteMode;;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
 0x3da1;PVA_InvalidPoolEntry;;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
 0x0801;DPS_InvalidParameterDefinition;;1;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
@@ -215,19 +305,39 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x0804;DPS_DataSetUninitialised;;4;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
 0x0805;DPS_DataSetFull;;5;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
 0x0806;DPS_PoolVarNull;;6;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-0x1c01;TCD_PacketLost;;1;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributor.h
+0x1000;TIM_UnsupportedTimeFormat;;0;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1c02;TCD_DestinationNotFound;;2;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributor.h
+0x1001;TIM_NotEnoughInformationForTargetFormat;;1;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1c03;TCD_ServiceIdAlreadyExists;;3;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributor.h
+0x1002;TIM_LengthMismatch;;2;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1b00;TCC_InvalidCcsdsVersion;;0;PACKET_CHECK;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1003;TIM_InvalidTimeFormat;;3;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1b01;TCC_InvalidApid;;1;PACKET_CHECK;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1004;TIM_InvalidDayOfYear;;4;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1b02;TCC_InvalidPacketType;;2;PACKET_CHECK;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1005;TIM_TimeDoesNotFitFormat;;5;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
-0x1b03;TCC_InvalidSecHeaderField;;3;PACKET_CHECK;fsfw/src/fsfw/tcdistribution/definitions.h
+0x3701;TSI_BadTimestamp;;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
-0x1b04;TCC_IncorrectPrimaryHeader;;4;PACKET_CHECK;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1d01;ATC_ActivityStarted;;1;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1b05;TCC_IncompletePacket;;5;PACKET_CHECK;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1d02;ATC_InvalidSubservice;;2;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1b06;TCC_InvalidPusVersion;;6;PACKET_CHECK;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1d03;ATC_IllegalApplicationData;;3;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1b07;TCC_IncorrectChecksum;;7;PACKET_CHECK;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1d04;ATC_SendTmFailed;;4;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1b08;TCC_IllegalPacketSubtype;;8;PACKET_CHECK;fsfw/src/fsfw/tcdistribution/definitions.h
+0x1d05;ATC_Timeout;;5;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1b09;TCC_IncorrectSecondaryHeader;;9;PACKET_CHECK;fsfw/src/fsfw/tcdistribution/definitions.h
+0x4c00;SPPA_NoPacketFound;;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x4c01;SPPA_SplitPacket;;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x2001;CSB_ExecutionComplete;;1;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2002;CSB_NoStepMessage;;2;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2003;CSB_ObjectBusy;;3;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2004;CSB_Busy;;4;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2005;CSB_InvalidTc;;5;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2006;CSB_InvalidObject;;6;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x2007;CSB_InvalidReply;;7;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
+0x1101;AL_Full;;1;ARRAY_LIST;fsfw/src/fsfw/container/ArrayList.h
+0x1801;FF_Full;;1;FIFO_CLASS;fsfw/src/fsfw/container/FIFOBase.h
+0x1802;FF_Empty;;2;FIFO_CLASS;fsfw/src/fsfw/container/FIFOBase.h
+0x1601;FMM_MapFull;;1;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
+0x1602;FMM_KeyDoesNotExist;;2;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
+0x1501;FM_KeyAlreadyExists;;1;FIXED_MAP;fsfw/src/fsfw/container/FixedMap.h
+0x1502;FM_MapFull;;2;FIXED_MAP;fsfw/src/fsfw/container/FixedMap.h
+0x1503;FM_KeyDoesNotExist;;3;FIXED_MAP;fsfw/src/fsfw/container/FixedMap.h
+0x2501;EV_ListenerNotFound;;1;EVENT_MANAGER_IF;fsfw/src/fsfw/events/EventManagerIF.h
+0x1701;HHI_ObjectNotHealthy;;1;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
+0x1702;HHI_InvalidHealthState;;2;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
+0x1703;HHI_IsExternallyControlled;;3;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
 0x3001;POS_InPowerTransition;;1;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
 0x3002;POS_SwitchStateMismatch;;2;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
 0x0501;PS_SwitchOn;;1;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
@@ -235,76 +345,23 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x0502;PS_SwitchTimeout;;2;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
 0x0503;PS_FuseOn;;3;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
 0x0504;PS_FuseOff;;4;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
-0x3b00;SPH_ConnBroken;;0;SEMAPHORE_IF;fsfw/src/fsfw/osal/common/TcpTmTcServer.h
+0x4300;FILS_GenericFileError;;0;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a01;IEC_NoConfigurationTable;;1;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x4301;FILS_GenericDirError;;1;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a02;IEC_NoCpuTable;;2;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x4302;FILS_FilesystemInactive;;2;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a03;IEC_InvalidWorkspaceAddress;;3;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x4303;FILS_GenericRenameError;;3;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a04;IEC_TooLittleWorkspace;;4;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x4304;FILS_IsBusy;;4;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a05;IEC_WorkspaceAllocation;;5;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x4305;FILS_InvalidParameters;;5;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a06;IEC_InterruptStackTooSmall;;6;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x430a;FILS_FileDoesNotExist;;10;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a07;IEC_ThreadExitted;;7;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x430b;FILS_FileAlreadyExists;;11;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a08;IEC_InconsistentMpInformation;;8;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x430c;FILS_NotAFile;;12;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a09;IEC_InvalidNode;;9;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x430d;FILS_FileLocked;;13;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a0a;IEC_NoMpci;;10;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x430e;FILS_PermissionDenied;;14;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a0b;IEC_BadPacket;;11;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x4315;FILS_DirectoryDoesNotExist;;21;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a0c;IEC_OutOfPackets;;12;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x4316;FILS_DirectoryAlreadyExists;;22;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a0d;IEC_OutOfGlobalObjects;;13;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x4317;FILS_NotADirectory;;23;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a0e;IEC_OutOfProxies;;14;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x4318;FILS_DirectoryNotEmpty;;24;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a0f;IEC_InvalidGlobalId;;15;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x431e;FILS_SequencePacketMissingWrite;;30;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a10;IEC_BadStackHook;;16;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
+0x431f;FILS_SequencePacketMissingRead;;31;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x2a11;IEC_BadAttributes;;17;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a12;IEC_ImplementationKeyCreateInconsistency;;18;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a13;IEC_ImplementationBlockingOperationCancel;;19;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a14;IEC_MutexObtainFromBadState;;20;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2a15;IEC_UnlimitedAndMaximumIs0;;21;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
-0x2600;FDI_YourFault;;0;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x2601;FDI_MyFault;;1;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x2602;FDI_ConfirmLater;;2;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x1e00;PUS_InvalidPusVersion;;0;PUS_IF;fsfw/src/fsfw/tmtcpacket/pus/PusIF.h
-0x1e01;PUS_InvalidCrc16;;1;PUS_IF;fsfw/src/fsfw/tmtcpacket/pus/PusIF.h
-0x0201;OM_InsertionFailed;;1;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x0202;OM_NotFound;;2;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x0203;OM_ChildInitFailed;;3;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x0204;OM_InternalErrReporterUninit;;4;OBJECT_MANAGER_IF;fsfw/src/fsfw/objectmanager/ObjectManagerIF.h
-0x2201;TMF_Busy;;1;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2202;TMF_LastPacketFound;;2;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2203;TMF_StopFetch;;3;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2204;TMF_Timeout;;4;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2205;TMF_TmChannelFull;;5;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2206;TMF_NotStored;;6;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2207;TMF_AllDeleted;;7;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2208;TMF_InvalidData;;8;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2209;TMF_NotReady;;9;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2101;TMB_Busy;;1;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2102;TMB_Full;;2;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2103;TMB_Empty;;3;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2104;TMB_NullRequested;;4;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2105;TMB_TooLarge;;5;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2106;TMB_NotReady;;6;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2107;TMB_DumpError;;7;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2108;TMB_CrcError;;8;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2109;TMB_Timeout;;9;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210a;TMB_IdlePacketFound;;10;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210b;TMB_TelecommandFound;;11;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210c;TMB_NoPusATm;;12;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210d;TMB_TooSmall;;13;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210e;TMB_BlockNotFound;;14;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x210f;TMB_InvalidRequest;;15;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2d01;PAW_UnknownDatatype;;1;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d02;PAW_DatatypeMissmatch;;2;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d03;PAW_Readonly;;3;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d04;PAW_TooBig;;4;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d05;PAW_SourceNotSet;;5;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d06;PAW_OutOfBounds;;6;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d07;PAW_NotSet;;7;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2d08;PAW_ColumnOrRowsZero;;8;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2e01;HPA_InvalidIdentifierId;;1;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2e02;HPA_InvalidDomainId;;2;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2e03;HPA_InvalidValue;;3;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x2e05;HPA_ReadOnly;;5;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
-0x3b01;SPH_SemaphoreTimeout;;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3b02;SPH_SemaphoreNotOwned;;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3b03;SPH_SemaphoreInvalid;;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
 0x1a01;TRC_NotEnoughSensors;;1;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
 0x1a02;TRC_LowestValueOol;;2;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
 0x1a03;TRC_HighestValueOol;;3;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
@@ -323,52 +380,34 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x31e2;LIM_WrongPid;;226;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
 0x31e3;LIM_WrongLimitId;;227;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
 0x31ee;LIM_MonitorNotFound;;238;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3601;CFDP_InvalidTlvType;;1;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3602;CFDP_InvalidDirectiveFields;;2;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3603;CFDP_InvalidPduDatafieldLen;;3;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3604;CFDP_InvalidAckDirectiveFields;;4;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3605;CFDP_MetadataCantParseOptions;;5;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3606;CFDP_FinishedCantParseFsResponses;;6;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3608;CFDP_FilestoreRequiresSecondFile;;8;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3609;CFDP_FilestoreResponseCantParseFsMessage;;9;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x2c01;CCS_BcIsSetVrCommand;;1;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2c02;CCS_BcIsUnlockCommand;;2;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cb0;CCS_BcIllegalCommand;;176;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cb1;CCS_BoardReadingNotFinished;;177;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cf0;CCS_NsPositiveW;;240;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cf1;CCS_NsNegativeW;;241;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cf2;CCS_NsLockout;;242;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cf3;CCS_FarmInLockout;;243;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cf4;CCS_FarmInWait;;244;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce0;CCS_WrongSymbol;;224;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce1;CCS_DoubleStart;;225;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce2;CCS_StartSymbolMissed;;226;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce3;CCS_EndWithoutStart;;227;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce4;CCS_TooLarge;;228;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce5;CCS_TooShort;;229;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce6;CCS_WrongTfVersion;;230;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce7;CCS_WrongSpacecraftId;;231;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce8;CCS_NoValidFrameType;;232;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ce9;CCS_CrcFailed;;233;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cea;CCS_VcNotFound;;234;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ceb;CCS_ForwardingFailed;;235;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cec;CCS_ContentTooLarge;;236;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2ced;CCS_ResidualData;;237;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cee;CCS_DataCorrupted;;238;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cef;CCS_IllegalSegmentationFlag;;239;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cd0;CCS_IllegalFlagCombination;;208;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cd1;CCS_ShorterThanHeader;;209;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cd2;CCS_TooShortBlockedPacket;;210;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x2cd3;CCS_TooShortMapExtraction;;211;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
 0x4201;PUS11_InvalidTypeTimeWindow;;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4202;PUS11_TimeshiftingNotPossible;;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4202;PUS11_InvalidTimeWindow;;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4203;PUS11_InvalidRelativeTime;;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4203;PUS11_TimeshiftingNotPossible;;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x3401;DC_NoReplyReceived;;1;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x4204;PUS11_InvalidRelativeTime;;4;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x3402;DC_ProtocolError;;2;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x0601;PP_DoItMyself;;1;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x3403;DC_Nullpointer;;3;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x0602;PP_PointsToVariable;;2;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x3404;DC_InvalidCookieType;;4;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x0603;PP_PointsToMemory;;3;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x3405;DC_NotActive;;5;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x0604;PP_ActivityCompleted;;4;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x3406;DC_TooMuchData;;6;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x0605;PP_PointsToVectorUint8;;5;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0606;PP_PointsToVectorUint16;;6;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0607;PP_PointsToVectorUint32;;7;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0608;PP_PointsToVectorFloat;;8;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06a0;PP_DumpNotSupported;;160;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e0;PP_InvalidSize;;224;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e1;PP_InvalidAddress;;225;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e2;PP_InvalidContent;;226;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e3;PP_UnalignedAccess;;227;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x06e4;PP_WriteProtected;;228;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x13e0;MH_UnknownCmd;;224;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
+0x13e1;MH_InvalidAddress;;225;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
+0x13e2;MH_InvalidSize;;226;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
+0x13e3;MH_StateMismatch;;227;MEMORY_HELPER;fsfw/src/fsfw/memory/MemoryHelper.h
+0x1201;AB_NeedSecondStep;;1;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x1202;AB_NeedToReconfigure;;2;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x1203;AB_ModeFallback;;3;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x1204;AB_ChildNotCommandable;;4;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x1205;AB_NeedToChangeHealth;;5;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x12a1;AB_NotEnoughChildrenInCorrectState;;161;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
 0x03a0;DHB_InvalidChannel;;160;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
 0x03b0;DHB_AperiodicReply;;176;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
 0x03b1;DHB_IgnoreReplyData;;177;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
@@ -378,12 +417,12 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x03d0;DHB_NoSwitch;;208;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
 0x03e0;DHB_ChildTimeout;;224;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
 0x03e1;DHB_SwitchFailed;;225;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
-0x1201;AB_NeedSecondStep;;1;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x3401;DC_NoReplyReceived;;1;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x1202;AB_NeedToReconfigure;;2;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x3402;DC_ProtocolError;;2;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x1203;AB_ModeFallback;;3;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x3403;DC_Nullpointer;;3;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x1204;AB_ChildNotCommandable;;4;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x3404;DC_InvalidCookieType;;4;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x1205;AB_NeedToChangeHealth;;5;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x3405;DC_NotActive;;5;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x12a1;AB_NotEnoughChildrenInCorrectState;;161;ASSEMBLY_BASE;fsfw/src/fsfw/devicehandlers/AssemblyBase.h
+0x3406;DC_TooMuchData;;6;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
 0x27a0;DHI_NoCommandData;;160;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27a1;DHI_CommandNotSupported;;161;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27a2;DHI_CommandAlreadySent;;162;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
@@ -405,67 +444,38 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x27c3;DHI_DeviceReplyInvalid;;195;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27d0;DHI_InvalidCommandParameter;;208;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27d1;DHI_InvalidNumberOrLengthOfParameters;;209;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x2401;MT_TooDetailedRequest;;1;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x1401;SE_BufferTooShort;;1;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
-0x2402;MT_TooGeneralRequest;;2;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x1402;SE_StreamTooShort;;2;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
-0x2403;MT_NoMatch;;3;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x1403;SE_TooManyElements;;3;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
-0x2404;MT_Full;;4;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x4500;HSPI_HalTimeoutRetval;;0;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x2405;MT_NewNodeCreated;;5;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x4501;HSPI_HalBusyRetval;;1;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x3f01;DLEE_StreamTooShort;;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x4502;HSPI_HalErrorRetval;;2;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x3f02;DLEE_DecodingError;;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x4601;HURT_UartReadFailure;;1;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
-0x2f01;ASC_TooLongForTargetType;;1;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x4602;HURT_UartReadSizeMissmatch;;2;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
-0x2f02;ASC_InvalidCharacters;;2;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x4603;HURT_UartRxBufferTooSmall;;3;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
-0x2f03;ASC_BufferTooSmall;;3;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x4801;HGIO_UnknownGpioId;;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x1701;HHI_ObjectNotHealthy;;1;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
+0x4802;HGIO_DriveGpioFailure;;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x1702;HHI_InvalidHealthState;;2;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
+0x4803;HGIO_GpioTypeFailure;;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x1703;HHI_IsExternallyControlled;;3;HAS_HEALTH_IF;fsfw/src/fsfw/health/HasHealthIF.h
+0x4804;HGIO_GpioInvalidInstance;;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x3201;CF_ObjectHasNoFunctions;;1;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
+0x4805;HGIO_GpioDuplicateDetected;;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x3202;CF_AlreadyCommanding;;2;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
+0x4806;HGIO_GpioInitFailed;;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x3301;HF_IsBusy;;1;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x4807;HGIO_GpioGetValueFailed;;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x3302;HF_InvalidParameters;;2;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x4400;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x3303;HF_ExecutionFinished;;3;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x4401;UXOS_CommandPending;Command is pending. This will also be returned if the user tries to load another command but a command is still pending;1;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x3304;HF_InvalidActionId;;4;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x4402;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x1000;TIM_UnsupportedTimeFormat;;0;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x1001;TIM_NotEnoughInformationForTargetFormat;;1;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x1002;TIM_LengthMismatch;;2;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x4406;UXOS_PcloseCallError;;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x1003;TIM_InvalidTimeFormat;;3;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x64a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;160;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
-0x1004;TIM_InvalidDayOfYear;;4;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x64a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;161;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
-0x1005;TIM_TimeDoesNotFitFormat;;5;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
+0x6a00;SDMA_OpOngoing;;0;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x3701;TSI_BadTimestamp;;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
+0x6a01;SDMA_AlreadyOn;;1;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x3c00;LPIF_PoolEntryNotFound;;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x6a02;SDMA_AlreadyMounted;;2;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x3c01;LPIF_PoolEntryTypeConflict;;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x6a03;SDMA_AlreadyOff;;3;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x3e00;HKM_QueueOrDestinationInvalid;;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x6a0a;SDMA_StatusFileNexists;;10;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x3e01;HKM_WrongHkPacketType;;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x6a0b;SDMA_StatusFileFormatInvalid;;11;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x3e02;HKM_ReportingStatusUnchanged;;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x6a0c;SDMA_MountError;;12;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x3e03;HKM_PeriodicHelperInvalid;;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x6a0d;SDMA_UnmountError;;13;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x3e04;HKM_PoolobjectNotFound;;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x6a0e;SDMA_SystemCallError;;14;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x3e05;HKM_DatasetNotFound;;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x6a0f;SDMA_PopenCallError;;15;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x2901;TC_InvalidTargetState;;1;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
-0x29f1;TC_AboveOperationalLimit;;241;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
-0x29f2;TC_BelowOperationalLimit;;242;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
-0x2001;CSB_ExecutionComplete;;1;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2002;CSB_NoStepMessage;;2;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2003;CSB_ObjectBusy;;3;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2004;CSB_Busy;;4;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2005;CSB_InvalidTc;;5;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2006;CSB_InvalidObject;;6;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x2007;CSB_InvalidReply;;7;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x4c00;SPPA_NoPacketFound;;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x4c01;SPPA_SplitPacket;;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x1d01;ATC_ActivityStarted;;1;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d02;ATC_InvalidSubservice;;2;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d03;ATC_IllegalApplicationData;;3;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d04;ATC_SendTmFailed;;4;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
-0x1d05;ATC_Timeout;;5;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
 0x6b00;SCBU_KeyNotFound;;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h
-0x64a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;160;FILE_SYSTEM_HELPER;bsp_q7s/memory/FilesystemHelper.h
-0x64a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;161;FILE_SYSTEM_HELPER;bsp_q7s/memory/FilesystemHelper.h
-0x6a00;SDMA_OpOngoing;;0;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x6a01;SDMA_AlreadyOn;;1;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x6a02;SDMA_AlreadyMounted;;2;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x6a03;SDMA_AlreadyOff;;3;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x6a0a;SDMA_StatusFileNexists;;10;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x6a0b;SDMA_StatusFileFormatInvalid;;11;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x6a0c;SDMA_MountError;;12;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x6a0d;SDMA_UnmountError;;13;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x6a0e;SDMA_SystemCallError;;14;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x6a0f;SDMA_PopenCallError;;15;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h

generators/events/event_parser.py

@@ -60,7 +60,7 @@ FILE_SEPARATOR = ";"
 SUBSYSTEM_DEFINITION_DESTINATIONS = [
     f"{FSFW_CONFIG_ROOT}/events/subsystemIdRanges.h",
     f"{OBSW_ROOT_DIR}/fsfw/src/fsfw/events/fwSubsystemIdRanges.h",
-    f"{OBSW_ROOT_DIR}/common/config/commonSubsystemIds.h",
+    f"{OBSW_ROOT_DIR}/common/config/eive/eventSubsystemIds.h",
 ]
 SUBSYSTEM_DEFS_DEST_AS_PATH = [Path(x) for x in SUBSYSTEM_DEFINITION_DESTINATIONS]
 

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 216 translations.
+ * @brief    Auto-generated event translation file. Contains 234 translations.
  * @details
- * Generated on: 2022-08-24 16:44:18
+ * Generated on: 2022-11-03 16:11:14
  */
 #include "translateEvents.h"
 
@@ -75,6 +75,7 @@ const char *OVERWRITING_HEALTH_STRING = "OVERWRITING_HEALTH";
 const char *TRYING_RECOVERY_STRING = "TRYING_RECOVERY";
 const char *RECOVERY_STEP_STRING = "RECOVERY_STEP";
 const char *RECOVERY_DONE_STRING = "RECOVERY_DONE";
+const char *HANDLE_PACKET_FAILED_STRING = "HANDLE_PACKET_FAILED";
 const char *RF_AVAILABLE_STRING = "RF_AVAILABLE";
 const char *RF_LOST_STRING = "RF_LOST";
 const char *BIT_LOCK_STRING = "BIT_LOCK";
@@ -85,6 +86,9 @@ const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
 const char *TC_DELETION_FAILED_STRING = "TC_DELETION_FAILED";
 const char *TEST_STRING = "TEST";
 const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
+const char *STORE_ERROR_STRING = "STORE_ERROR";
+const char *MSG_QUEUE_ERROR_STRING = "MSG_QUEUE_ERROR";
+const char *SERIALIZATION_ERROR_STRING = "SERIALIZATION_ERROR";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
@@ -97,11 +101,15 @@ const char *SWITCH_ALREADY_ON_STRING = "SWITCH_ALREADY_ON";
 const char *SWITCH_ALREADY_OFF_STRING = "SWITCH_ALREADY_OFF";
 const char *MAIN_SWITCH_TIMEOUT_STRING = "MAIN_SWITCH_TIMEOUT";
 const char *FAULTY_HEATER_WAS_ON_STRING = "FAULTY_HEATER_WAS_ON";
+const char *BURN_PHASE_START_STRING = "BURN_PHASE_START";
+const char *BURN_PHASE_DONE_STRING = "BURN_PHASE_DONE";
 const char *MAIN_SWITCH_ON_TIMEOUT_STRING = "MAIN_SWITCH_ON_TIMEOUT";
 const char *MAIN_SWITCH_OFF_TIMEOUT_STRING = "MAIN_SWITCH_OFF_TIMEOUT";
-const char *DEPLOYMENT_FAILED_STRING = "DEPLOYMENT_FAILED";
 const char *DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA1_GPIO_SWTICH_ON_FAILED";
 const char *DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_ON_FAILED";
+const char *DEPL_SA1_GPIO_SWTICH_OFF_FAILED_STRING = "DEPL_SA1_GPIO_SWTICH_OFF_FAILED";
+const char *DEPL_SA2_GPIO_SWTICH_OFF_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_OFF_FAILED";
+const char *AUTONOMOUS_DEPLOYMENT_COMPLETED_STRING = "AUTONOMOUS_DEPLOYMENT_COMPLETED";
 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";
@@ -136,6 +144,7 @@ const char *CARRIER_LOCK_STRING = "CARRIER_LOCK";
 const char *BIT_LOCK_PDEC_STRING = "BIT_LOCK_PDEC";
 const char *LOST_CARRIER_LOCK_PDEC_STRING = "LOST_CARRIER_LOCK_PDEC";
 const char *LOST_BIT_LOCK_PDEC_STRING = "LOST_BIT_LOCK_PDEC";
+const char *POLL_ERROR_PDEC_STRING = "POLL_ERROR_PDEC";
 const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
 const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
 const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
@@ -217,6 +226,15 @@ const char *ALLOC_FAILURE_STRING = "ALLOC_FAILURE";
 const char *REBOOT_SW_STRING = "REBOOT_SW";
 const char *REBOOT_MECHANISM_TRIGGERED_STRING = "REBOOT_MECHANISM_TRIGGERED";
 const char *REBOOT_HW_STRING = "REBOOT_HW";
+const char *NO_SD_CARD_ACTIVE_STRING = "NO_SD_CARD_ACTIVE";
+const char *MISSING_PACKET_STRING = "MISSING_PACKET";
+const char *EXPERIMENT_TIMEDOUT_STRING = "EXPERIMENT_TIMEDOUT";
+const char *MULTI_PACKET_COMMAND_DONE_STRING = "MULTI_PACKET_COMMAND_DONE";
+const char *SET_CONFIGFILEVALUE_FAILED_STRING = "SET_CONFIGFILEVALUE_FAILED";
+const char *GET_CONFIGFILEVALUE_FAILED_STRING = "GET_CONFIGFILEVALUE_FAILED";
+const char *INSERT_CONFIGFILEVALUE_FAILED_STRING = "INSERT_CONFIGFILEVALUE_FAILED";
+const char *WRITE_CONFIGFILE_FAILED_STRING = "WRITE_CONFIGFILE_FAILED";
+const char *READ_CONFIGFILE_FAILED_STRING = "READ_CONFIGFILE_FAILED";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -360,6 +378,8 @@ const char *translateEvents(Event event) {
       return RECOVERY_STEP_STRING;
     case (7512):
       return RECOVERY_DONE_STRING;
+    case (7600):
+      return HANDLE_PACKET_FAILED_STRING;
     case (7900):
       return RF_AVAILABLE_STRING;
     case (7901):
@@ -380,6 +400,12 @@ const char *translateEvents(Event event) {
       return TEST_STRING;
     case (10600):
       return CHANGE_OF_SETUP_PARAMETER_STRING;
+    case (10800):
+      return STORE_ERROR_STRING;
+    case (10801):
+      return MSG_QUEUE_ERROR_STRING;
+    case (10802):
+      return SERIALIZATION_ERROR_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -405,15 +431,23 @@ const char *translateEvents(Event event) {
     case (11407):
       return FAULTY_HEATER_WAS_ON_STRING;
     case (11500):
-      return MAIN_SWITCH_ON_TIMEOUT_STRING;
+      return BURN_PHASE_START_STRING;
     case (11501):
-      return MAIN_SWITCH_OFF_TIMEOUT_STRING;
+      return BURN_PHASE_DONE_STRING;
     case (11502):
-      return DEPLOYMENT_FAILED_STRING;
+      return MAIN_SWITCH_ON_TIMEOUT_STRING;
     case (11503):
-      return DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING;
+      return MAIN_SWITCH_OFF_TIMEOUT_STRING;
     case (11504):
+      return DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING;
+    case (11505):
       return DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING;
+    case (11506):
+      return DEPL_SA1_GPIO_SWTICH_OFF_FAILED_STRING;
+    case (11507):
+      return DEPL_SA2_GPIO_SWTICH_OFF_FAILED_STRING;
+    case (11508):
+      return AUTONOMOUS_DEPLOYMENT_COMPLETED_STRING;
     case (11601):
       return MEMORY_READ_RPT_CRC_FAILURE_STRING;
     case (11602):
@@ -482,6 +516,8 @@ const char *translateEvents(Event event) {
       return LOST_CARRIER_LOCK_PDEC_STRING;
     case (12406):
       return LOST_BIT_LOCK_PDEC_STRING;
+    case (12407):
+      return POLL_ERROR_PDEC_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -644,6 +680,24 @@ const char *translateEvents(Event event) {
       return REBOOT_MECHANISM_TRIGGERED_STRING;
     case (13703):
       return REBOOT_HW_STRING;
+    case (13704):
+      return NO_SD_CARD_ACTIVE_STRING;
+    case (13800):
+      return MISSING_PACKET_STRING;
+    case (13801):
+      return EXPERIMENT_TIMEDOUT_STRING;
+    case (13802):
+      return MULTI_PACKET_COMMAND_DONE_STRING;
+    case (13901):
+      return SET_CONFIGFILEVALUE_FAILED_STRING;
+    case (13902):
+      return GET_CONFIGFILEVALUE_FAILED_STRING;
+    case (13903):
+      return INSERT_CONFIGFILEVALUE_FAILED_STRING;
+    case (13904):
+      return WRITE_CONFIGFILE_FAILED_STRING;
+    case (13905):
+      return READ_CONFIGFILE_FAILED_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

generators/objects/objects.py

@@ -51,7 +51,7 @@ OBJECTS_PATH = Path(f"{FSFW_CONFIG_ROOT}/objects/systemObjectList.h")
 FRAMEWORK_OBJECT_PATH = Path(
     f"{OBSW_ROOT_DIR}/fsfw/src/fsfw/objectmanager/frameworkObjects.h"
 )
-COMMON_OBJECTS_PATH = Path(f"{OBSW_ROOT_DIR}/common/config/commonObjects.h")
+COMMON_OBJECTS_PATH = Path(f"{OBSW_ROOT_DIR}/common/config/eive/objects.h")
 OBJECTS_DEFINITIONS = [OBJECTS_PATH, FRAMEWORK_OBJECT_PATH, COMMON_OBJECTS_PATH]
 
 SQL_DELETE_OBJECTS_CMD = """

generators/objects/translateObjects.cpp

@@ -1,14 +1,15 @@
 /**
  * @brief  Auto-generated object translation file.
  * @details
- * Contains 133 translations.
+ * Contains 142 translations.
- * Generated on: 2022-08-24 16:44:18
+ * Generated on: 2022-11-03 16:11:14
  */
 #include "translateObjects.h"
 
 const char *P60DOCK_TEST_TASK_STRING = "P60DOCK_TEST_TASK";
 const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
 const char *CORE_CONTROLLER_STRING = "CORE_CONTROLLER";
+const char *GLOBAL_JSON_CFG_STRING = "GLOBAL_JSON_CFG";
 const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *MGM_0_LIS3_HANDLER_STRING = "MGM_0_LIS3_HANDLER";
 const char *GYRO_0_ADIS_HANDLER_STRING = "GYRO_0_ADIS_HANDLER";
@@ -54,6 +55,7 @@ const char *PTME_CONFIG_STRING = "PTME_CONFIG";
 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 *SCEX_STRING = "SCEX";
 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";
@@ -77,6 +79,7 @@ const char *RTD_15_IC18_IMTQ_STRING = "RTD_15_IC18_IMTQ";
 const char *SYRLINKS_HK_HANDLER_STRING = "SYRLINKS_HK_HANDLER";
 const char *ARDUINO_COM_IF_STRING = "ARDUINO_COM_IF";
 const char *GPIO_IF_STRING = "GPIO_IF";
+const char *SCEX_UART_READER_STRING = "SCEX_UART_READER";
 const char *SPI_MAIN_COM_IF_STRING = "SPI_MAIN_COM_IF";
 const char *SPI_RW_COM_IF_STRING = "SPI_RW_COM_IF";
 const char *SPI_RTD_COM_IF_STRING = "SPI_RTD_COM_IF";
@@ -136,7 +139,13 @@ const char *ACS_BOARD_ASS_STRING = "ACS_BOARD_ASS";
 const char *SUS_BOARD_ASS_STRING = "SUS_BOARD_ASS";
 const char *TCS_BOARD_ASS_STRING = "TCS_BOARD_ASS";
 const char *RW_ASS_STRING = "RW_ASS";
+const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
+const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
 const char *TM_FUNNEL_STRING = "TM_FUNNEL";
+const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
+const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
+const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
+const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *CCSDS_IP_CORE_BRIDGE_STRING = "CCSDS_IP_CORE_BRIDGE";
 const char *NO_OBJECT_STRING = "NO_OBJECT";
 
@@ -148,6 +157,8 @@ const char *translateObject(object_id_t object) {
       return ACS_CONTROLLER_STRING;
     case 0x43000003:
       return CORE_CONTROLLER_STRING;
+    case 0x43000006:
+      return GLOBAL_JSON_CFG_STRING;
     case 0x43400001:
       return THERMAL_CONTROLLER_STRING;
     case 0x44120006:
@@ -238,6 +249,8 @@ const char *translateObject(object_id_t object) {
       return PLOC_SUPERVISOR_HANDLER_STRING;
     case 0x44330017:
       return PLOC_SUPERVISOR_HELPER_STRING;
+    case 0x44330032:
+      return SCEX_STRING;
     case 0x444100A2:
       return SOLAR_ARRAY_DEPL_HANDLER_STRING;
     case 0x444100A4:
@@ -284,6 +297,8 @@ const char *translateObject(object_id_t object) {
       return ARDUINO_COM_IF_STRING;
     case 0x49010005:
       return GPIO_IF_STRING;
+    case 0x49010006:
+      return SCEX_UART_READER_STRING;
     case 0x49020004:
       return SPI_MAIN_COM_IF_STRING;
     case 0x49020005:
@@ -402,8 +417,20 @@ const char *translateObject(object_id_t object) {
       return TCS_BOARD_ASS_STRING;
     case 0x73000004:
       return RW_ASS_STRING;
+    case 0x73000005:
+      return CFDP_HANDLER_STRING;
+    case 0x73000006:
+      return CFDP_DISTRIBUTOR_STRING;
     case 0x73000100:
       return TM_FUNNEL_STRING;
+    case 0x73000101:
+      return PUS_TM_FUNNEL_STRING;
+    case 0x73000102:
+      return CFDP_TM_FUNNEL_STRING;
+    case 0x73010000:
+      return EIVE_SYSTEM_STRING;
+    case 0x73010001:
+      return ACS_SUBSYSTEM_STRING;
     case 0x73500000:
       return CCSDS_IP_CORE_BRIDGE_STRING;
     case 0xFFFFFFFF:

generators/returnvalues/returnvalues_parser.py

@@ -43,7 +43,7 @@ BSP_PATH = f"{OBSW_ROOT_DIR}/{BSP_DIR_NAME}"
 
 INTERFACE_DEFINITION_FILES = [
     f"{OBSW_ROOT_DIR}/fsfw/src/fsfw/returnvalues/FwClassIds.h",
-    f"{OBSW_ROOT_DIR}/common/config/commonClassIds.h",
+    f"{OBSW_ROOT_DIR}/common/config/eive/resultClassIds.h",
     f"{FSFW_CONFIG_ROOT}/returnvalues/classIds.h",
 ]
 RETURNVALUE_SOURCES = [

linux/CMakeLists.txt

@@ -4,6 +4,6 @@ add_subdirectory(callbacks)
 add_subdirectory(boardtest)
 add_subdirectory(devices)
 add_subdirectory(fsfwconfig)
-add_subdirectory(obc)
+add_subdirectory(ipcore)
 
-target_sources(${OBSW_NAME} PUBLIC ObjectFactory.cpp)
+target_sources(${OBSW_NAME} PUBLIC ObjectFactory.cpp InitMission.cpp)

linux/InitMission.cpp

@@ -0,0 +1,47 @@
+#include "InitMission.h"
+
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/tasks/PeriodicTaskIF.h>
+#include <mission/utility/InitMission.h>
+
+#include "OBSWConfig.h"
+#include "ObjectFactory.h"
+
+void scheduling::schedulingScex(TaskFactory& factory, PeriodicTaskIF*& scexDevHandler,
+                                PeriodicTaskIF*& scexReaderTask) {
+  using namespace initmission;
+  ReturnValue_t result = returnvalue::OK;
+#if OBSW_PRINT_MISSED_DEADLINES == 1
+  void (*missedDeadlineFunc)(void) = TaskFactory::printMissedDeadline;
+#else
+  void (*missedDeadlineFunc)(void) = nullptr;
+#endif
+  scexDevHandler = factory.createPeriodicTask(
+      "SCEX_DEV", 35, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.5, missedDeadlineFunc);
+
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::PERFORM_OPERATION);
+  if (result != returnvalue::OK) {
+    printAddObjectError("SCEX_DEV", objects::SCEX);
+  }
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_WRITE);
+  if (result != returnvalue::OK) {
+    printAddObjectError("SCEX_DEV", objects::SCEX);
+  }
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_WRITE);
+  if (result != returnvalue::OK) {
+    printAddObjectError("SCEX_DEV", objects::SCEX);
+  }
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_READ);
+  if (result != returnvalue::OK) {
+    printAddObjectError("SCEX_DEV", objects::SCEX);
+  }
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_READ);
+
+  result = returnvalue::OK;
+  scexReaderTask = factory.createPeriodicTask(
+      "SCEX_UART_READER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
+  result = scexReaderTask->addComponent(objects::SCEX_UART_READER);
+  if (result != returnvalue::OK) {
+    printAddObjectError("SCEX_UART_READER", objects::SCEX_UART_READER);
+  }
+}

linux/InitMission.h

@@ -0,0 +1,7 @@
+#pragma once
+#include <fsfw/tasks/TaskFactory.h>
+
+namespace scheduling {
+void schedulingScex(TaskFactory& factory, PeriodicTaskIF*& scexDevHandler,
+                    PeriodicTaskIF*& scexReaderTask);
+}

linux/ObjectFactory.cpp

@@ -1,20 +1,21 @@
 #include "ObjectFactory.h"
 
 #include <fsfw/power/PowerSwitchIF.h>
+#include <fsfw/subsystem/Subsystem.h>
 #include <fsfw_hal/common/gpio/GpioCookie.h>
 #include <fsfw_hal/common/gpio/GpioIF.h>
 #include <fsfw_hal/common/gpio/gpioDefinitions.h>
 #include <fsfw_hal/linux/spi/SpiComIF.h>
 #include <fsfw_hal/linux/spi/SpiCookie.h>
+#include <fsfw_hal/linux/uart/UartCookie.h>
 #include <linux/callbacks/gpioCallbacks.h>
 #include <linux/devices/Max31865RtdLowlevelHandler.h>
 #include <mission/controller/AcsController.h>
 #include <mission/controller/ThermalController.h>
 #include <mission/devices/Max31865EiveHandler.h>
 #include <mission/devices/Max31865PT1000Handler.h>
+#include <mission/devices/ScexDeviceHandler.h>
 #include <mission/devices/SusHandler.h>
-#include <mission/system/SusAssembly.h>
-#include <mission/system/TcsBoardAssembly.h>
 #include <mission/system/fdir/RtdFdir.h>
 #include <mission/system/fdir/SusFdir.h>
 
@@ -22,6 +23,10 @@
 #include "devConf.h"
 #include "devices/addresses.h"
 #include "devices/gpioIds.h"
+#include "eive/definitions.h"
+#include "mission/system/objects/SusAssembly.h"
+#include "mission/system/objects/TcsBoardAssembly.h"
+#include "mission/system/tree/acsModeTree.h"
 
 void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF,
                                               PowerSwitchIF* pwrSwitcher, std::string spiDev) {
@@ -76,7 +81,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[0] =
       new SusHandler(objects::SUS_0_N_LOC_XFYFZM_PT_XF, 0, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
-  susHandlers[0]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[0]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, SUS::MAX_CMD_SIZE,
@@ -84,7 +88,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[1] =
       new SusHandler(objects::SUS_1_N_LOC_XBYFZM_PT_XB, 1, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_1_N_LOC_XBYFZM_PT_XB);
-  susHandlers[1]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[1]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, SUS::MAX_CMD_SIZE,
@@ -92,7 +95,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[2] =
       new SusHandler(objects::SUS_2_N_LOC_XFYBZB_PT_YB, 2, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_2_N_LOC_XFYBZB_PT_YB);
-  susHandlers[2]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[2]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, SUS::MAX_CMD_SIZE,
@@ -100,7 +102,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[3] =
       new SusHandler(objects::SUS_3_N_LOC_XFYBZF_PT_YF, 3, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_3_N_LOC_XFYBZF_PT_YF);
-  susHandlers[3]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[3]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, SUS::MAX_CMD_SIZE,
@@ -108,7 +109,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[4] =
       new SusHandler(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, 4, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_4_N_LOC_XMYFZF_PT_ZF);
-  susHandlers[4]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[4]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, SUS::MAX_CMD_SIZE,
@@ -116,7 +116,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[5] =
       new SusHandler(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, 5, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_5_N_LOC_XFYMZB_PT_ZB);
-  susHandlers[5]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[5]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, SUS::MAX_CMD_SIZE,
@@ -124,7 +123,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[6] =
       new SusHandler(objects::SUS_6_R_LOC_XFYBZM_PT_XF, 6, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_6_R_LOC_XFYBZM_PT_XF);
-  susHandlers[6]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[6]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, SUS::MAX_CMD_SIZE,
@@ -132,7 +130,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[7] =
       new SusHandler(objects::SUS_7_R_LOC_XBYBZM_PT_XB, 7, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_7_R_LOC_XBYBZM_PT_XB);
-  susHandlers[7]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[7]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, SUS::MAX_CMD_SIZE,
@@ -140,7 +137,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[8] =
       new SusHandler(objects::SUS_8_R_LOC_XBYBZB_PT_YB, 8, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_8_R_LOC_XBYBZB_PT_YB);
-  susHandlers[8]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[8]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, SUS::MAX_CMD_SIZE,
@@ -148,7 +144,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[9] =
       new SusHandler(objects::SUS_9_R_LOC_XBYBZB_PT_YF, 9, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_9_R_LOC_XBYBZB_PT_YF);
-  susHandlers[9]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[9]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, SUS::MAX_CMD_SIZE,
@@ -156,7 +151,6 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[10] =
       new SusHandler(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, 10, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_10_N_LOC_XMYBZF_PT_ZF);
-  susHandlers[10]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[10]->setCustomFdir(fdir);
 
   spiCookie = new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, SUS::MAX_CMD_SIZE,
@@ -164,11 +158,24 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
   susHandlers[11] =
       new SusHandler(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, 11, objects::SPI_MAIN_COM_IF, spiCookie);
   fdir = new SusFdir(objects::SUS_11_R_LOC_XBYMZB_PT_ZB);
-  susHandlers[11]->setParent(objects::SUS_BOARD_ASS);
   susHandlers[11]->setCustomFdir(fdir);
 
+  std::array<object_id_t, 12> susIds = {
+      objects::SUS_0_N_LOC_XFYFZM_PT_XF,  objects::SUS_1_N_LOC_XBYFZM_PT_XB,
+      objects::SUS_2_N_LOC_XFYBZB_PT_YB,  objects::SUS_3_N_LOC_XFYBZF_PT_YF,
+      objects::SUS_4_N_LOC_XMYFZF_PT_ZF,  objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
+      objects::SUS_6_R_LOC_XFYBZM_PT_XF,  objects::SUS_7_R_LOC_XBYBZM_PT_XB,
+      objects::SUS_8_R_LOC_XBYBZB_PT_YB,  objects::SUS_9_R_LOC_XBYBZB_PT_YF,
+      objects::SUS_10_N_LOC_XMYBZF_PT_ZF, objects::SUS_11_R_LOC_XBYMZB_PT_ZB};
+  SusAssHelper susAssHelper = SusAssHelper(susIds);
+  auto susAss = new SusAssembly(objects::SUS_BOARD_ASS, pwrSwitcher, susAssHelper);
   for (auto& sus : susHandlers) {
     if (sus != nullptr) {
+      ReturnValue_t result = sus->connectModeTreeParent(*susAss);
+      if (result != returnvalue::OK) {
+        sif::error << "Connecting SUS " << sus->getObjectId() << " to SUS assembly failed"
+                   << std::endl;
+      }
 #if OBSW_TEST_SUS == 1
       sus->setStartUpImmediately();
       sus->setToGoToNormalMode(true);
@@ -178,17 +185,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
 #endif
     }
   }
-  std::array<object_id_t, 12> susIds = {
+  susAss->connectModeTreeParent(satsystem::ACS_SUBSYSTEM);
-      objects::SUS_0_N_LOC_XFYFZM_PT_XF,  objects::SUS_1_N_LOC_XBYFZM_PT_XB,
-      objects::SUS_2_N_LOC_XFYBZB_PT_YB,  objects::SUS_3_N_LOC_XFYBZF_PT_YF,
-      objects::SUS_4_N_LOC_XMYFZF_PT_ZF,  objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
-      objects::SUS_6_R_LOC_XFYBZM_PT_XF,  objects::SUS_7_R_LOC_XBYBZM_PT_XB,
-      objects::SUS_8_R_LOC_XBYBZB_PT_YB,  objects::SUS_9_R_LOC_XBYBZB_PT_YF,
-      objects::SUS_10_N_LOC_XMYBZF_PT_ZF, objects::SUS_11_R_LOC_XBYMZB_PT_ZB};
-  SusAssHelper susAssHelper = SusAssHelper(susIds);
-  auto susAss =
-      new SusAssembly(objects::SUS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher, susAssHelper);
-  static_cast<void>(susAss);
 #endif /* OBSW_ADD_SUN_SENSORS == 1 */
 }
 
@@ -290,6 +287,11 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
   std::array<SpiCookie*, NUM_RTDS> rtdCookies = {};
   std::array<Max31865EiveHandler*, NUM_RTDS> rtds = {};
   RtdFdir* rtdFdir = nullptr;
+
+  TcsBoardHelper helper(rtdInfos);
+  TcsBoardAssembly* tcsBoardAss = new TcsBoardAssembly(
+      objects::TCS_BOARD_ASS, pwrSwitcher, pcdu::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
+  static_cast<void>(tcsBoardAss);
   // Create special low level reader communication interface
   new Max31865RtdReader(objects::SPI_RTD_COM_IF, comIF, gpioComIF);
   for (uint8_t idx = 0; idx < NUM_RTDS; idx++) {
@@ -301,7 +303,11 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
     rtds[idx] =
         new Max31865EiveHandler(rtdInfos[idx].first, objects::SPI_RTD_COM_IF, rtdLowLevelCookie);
     rtds[idx]->setDeviceInfo(idx, rtdInfos[idx].second);
-    rtds[idx]->setParent(objects::TCS_BOARD_ASS);
+    ReturnValue_t result = rtds[idx]->connectModeTreeParent(*tcsBoardAss);
+    if (result != returnvalue::OK) {
+      sif::error << "Connecting RTD " << static_cast<int>(idx) << " to RTD Assembly failed"
+                 << std::endl;
+    }
     rtdFdir = new RtdFdir(rtdInfos[idx].first);
     rtds[idx]->setCustomFdir(rtdFdir);
 #if OBSW_DEBUG_RTD == 1
@@ -313,22 +319,45 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
 #endif
   }
 
-  TcsBoardHelper helper(rtdInfos);
-  TcsBoardAssembly* tcsBoardAss =
-      new TcsBoardAssembly(objects::TCS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher,
-                           pcdu::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
-  static_cast<void>(tcsBoardAss);
 #endif  // OBSW_ADD_RTD_DEVICES == 1
 }
 
-void ObjectFactory::createThermalController() {
+void ObjectFactory::createScexComponents(std::string uartDev, PowerSwitchIF* pwrSwitcher,
-  new ThermalController(objects::THERMAL_CONTROLLER, objects::NO_OBJECT);
+                                         SdCardMountedIF& mountedIF, bool onImmediately,
+                                         std::optional<power::Switch_t> switchId) {
+  auto* cookie = new UartCookie(objects::SCEX, uartDev, uart::SCEX_BAUD, 4096);
+  cookie->setTwoStopBits();
+  // cookie->setParityEven();
+  auto scexUartReader = new ScexUartReader(objects::SCEX_UART_READER);
+  auto scexHandler = new ScexDeviceHandler(objects::SCEX, *scexUartReader, cookie, mountedIF);
+  if (onImmediately) {
+    scexHandler->setStartUpImmediately();
+  }
+  if (switchId) {
+    scexHandler->setPowerSwitcher(*pwrSwitcher, switchId.value());
+  }
 }
 
-void ObjectFactory::createAcsController() { new AcsController(objects::ACS_CONTROLLER); }
+void ObjectFactory::createThermalController() {
+  new ThermalController(objects::THERMAL_CONTROLLER);
+}
+
+AcsController* ObjectFactory::createAcsController(bool connectSubsystem) {
+  auto acsCtrl = new AcsController(objects::ACS_CONTROLLER);
+  if (connectSubsystem) {
+    acsCtrl->connectModeTreeParent(satsystem::ACS_SUBSYSTEM);
+  }
+  return acsCtrl;
+}
 
 void ObjectFactory::gpioChecker(ReturnValue_t result, std::string output) {
   if (result != returnvalue::OK) {
     sif::error << "ObjectFactory: Adding GPIOs failed for " << output << std::endl;
   }
 }
+
+void ObjectFactory::addTmtcIpCoresToFunnels(CcsdsIpCoreHandler& ipCoreHandler,
+                                            PusTmFunnel& pusFunnel, CfdpTmFunnel& cfdpFunnel) {
+  cfdpFunnel.addDestination(ipCoreHandler, config::LIVE_TM);
+  pusFunnel.addDestination(ipCoreHandler, config::LIVE_TM);
+}

linux/ObjectFactory.h

@@ -1,13 +1,20 @@
 #pragma once
 
+#include <fsfw/power/definitions.h>
 #include <fsfw/returnvalues/returnvalue.h>
 #include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
+#include <mission/memory/SdCardMountedIF.h>
+#include <mission/tmtc/CcsdsIpCoreHandler.h>
+#include <mission/tmtc/CfdpTmFunnel.h>
+#include <mission/tmtc/PusTmFunnel.h>
 
+#include <optional>
 #include <string>
 
 class GpioIF;
 class SpiComIF;
 class PowerSwitchIF;
+class AcsController;
 
 namespace ObjectFactory {
 
@@ -16,9 +23,16 @@ void createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF, PowerSwitc
 void createRtdComponents(std::string spiDev, GpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher,
                          SpiComIF* comIF);
 
+void createScexComponents(std::string uartDev, PowerSwitchIF* pwrSwitcher,
+                          SdCardMountedIF& mountedIF, bool onImmediately,
+                          std::optional<power::Switch_t> switchId);
+
 void gpioChecker(ReturnValue_t result, std::string output);
 
 void createThermalController();
-void createAcsController();
+AcsController* createAcsController(bool connectSubsystem);
+
+void addTmtcIpCoresToFunnels(CcsdsIpCoreHandler& ipCoreHandler, PusTmFunnel& pusFunnel,
+                             CfdpTmFunnel& cfdpFunnel);
 
 }  // namespace ObjectFactory

linux/boardtest/UartTestClass.cpp

@@ -3,14 +3,21 @@
 #include <errno.h>  // Error integer and strerror() function
 #include <fcntl.h>  // Contains file controls like O_RDWR
 #include <fsfw/tasks/TaskFactory.h>
+#include <fsfw_hal/linux/uart/UartCookie.h>
+#include <linux/devices/ScexDleParser.h>
+#include <linux/devices/ScexHelper.h>
+#include <linux/devices/ScexUartReader.h>
 #include <unistd.h>  // write(), read(), close()
 
+#include <random>
+#include <string>
+
 #include "OBSWConfig.h"
 #include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/globalfunctions/DleEncoder.h"
 #include "fsfw/globalfunctions/arrayprinter.h"
 #include "fsfw/serviceinterface.h"
-#include "mission/devices/devicedefinitions/SCEXDefinitions.h"
+#include "mission/devices/devicedefinitions/ScexDefinitions.h"
 
 #define GPS_REPLY_WIRETAPPING 0
 
@@ -18,7 +25,25 @@
 #define RPI_TEST_GPS_HANDLER 0
 #endif
 
-UartTestClass::UartTestClass(object_id_t objectId) : TestTask(objectId) { mode = TestModes::SCEX; }
+using namespace returnvalue;
+
+UartTestClass::UartTestClass(object_id_t objectId) : TestTask(objectId) {
+  mode = TestModes::SCEX;
+  scexMode = ScexModes::SIMPLE;
+  // No one-cell and all-cell support implemented yet
+  currCmd = scex::Cmds::PING;
+  if (scexMode == ScexModes::SIMPLE) {
+    auto encodingBuf = new std::array<uint8_t, 4096>;
+    DleParser::BufPair encodingBufPair{encodingBuf->data(), encodingBuf->size()};
+    auto decodedBuf = new std::array<uint8_t, 4096>;
+    DleParser::BufPair decodingBufPair{decodedBuf->data(), decodedBuf->size()};
+    // TODO: Code changes but this test class has not, might not work like this anymore
+    dleParser = new ScexDleParser(*(new SimpleRingBuffer(4096, true)), dleEncoder, encodingBufPair,
+                                  decodingBufPair);
+  } else {
+    reader = new ScexUartReader(objects::SCEX_UART_READER);
+  }
+}
 
 ReturnValue_t UartTestClass::initialize() {
   if (mode == TestModes::GPS) {
@@ -44,14 +69,14 @@ void UartTestClass::gpsInit() {
 #if RPI_TEST_GPS_HANDLER == 1
   int result = lwgps_init(&gpsData);
   if (result == 0) {
-    sif::warning << "lwgps_init error: " << result << std::endl;
+    sif::warning << "UartTestClass::gpsInit: lwgps_init error: " << result << std::endl;
   }
 
   /* Get file descriptor */
   serialPort = open("/dev/serial0", O_RDWR);
   if (serialPort < 0) {
-    sif::warning << "open call failed with error [" << errno << ", " << strerror(errno)
+    sif::warning << "UartTestClass::gpsInit: open call failed with error [" << errno << ", "
-                 << std::endl;
+                 << strerror(errno) << std::endl;
   }
   /* Setting up UART parameters */
   tty.c_cflag &= ~PARENB;         // Clear parity bit
@@ -79,8 +104,8 @@ void UartTestClass::gpsInit() {
   cfsetispeed(&tty, B9600);
   cfsetospeed(&tty, B9600);
   if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
-    sif::warning << "tcsetattr call failed with error [" << errno << ", " << strerror(errno)
+    sif::warning << "UartTestClass::gpsInit: tcsetattr call failed with error [" << errno << ", "
-                 << std::endl;
+                 << strerror(errno) << std::endl;
     ;
   }
   // Flush received and unread data. Those are old NMEA strings which are not relevant anymore
@@ -95,11 +120,11 @@ void UartTestClass::gpsPeriodic() {
     bytesRead = read(serialPort, reinterpret_cast<void*>(recBuf.data()),
                      static_cast<unsigned int>(recBuf.size()));
     if (bytesRead < 0) {
-      sif::warning << "UartTestClass::performPeriodicAction: read call failed with error [" << errno
+      sif::warning << "UartTestClass::gpsPeriodic: read call failed with error [" << errno << ", "
-                   << ", " << strerror(errno) << "]" << std::endl;
+                   << strerror(errno) << "]" << std::endl;
       break;
     } else if (bytesRead >= static_cast<int>(recBuf.size())) {
-      sif::debug << "UartTestClass::performPeriodicAction: "
+      sif::debug << "UartTestClass::gpsPeriodic: "
                     "recv buffer might not be large enough"
                  << std::endl;
     } else if (bytesRead > 0) {
@@ -109,7 +134,7 @@ void UartTestClass::gpsPeriodic() {
 #endif
       int result = lwgps_process(&gpsData, recBuf.data(), bytesRead);
       if (result == 0) {
-        sif::warning << "UartTestClass::performPeriodicAction: lwgps_process error" << std::endl;
+        sif::warning << "UartTestClass::gpsPeriodic: lwgps_process error" << std::endl;
       }
       recvCnt++;
       if (recvCnt == 6) {
@@ -127,6 +152,114 @@ void UartTestClass::gpsPeriodic() {
 }
 
 void UartTestClass::scexInit() {
+  if (scexMode == ScexModes::SIMPLE) {
+    scexSimpleInit();
+  } else {
+    if (reader == nullptr) {
+      sif::warning << "UartTestClass::scexInit: Reader invalid" << std::endl;
+      return;
+    }
+#if defined(RASPBERRY_PI)
+    std::string devname = "/dev/serial0";
+#else
+    std::string devname = "/dev/ul-scex";
+#endif
+    uartCookie = new UartCookie(this->getObjectId(), devname, UartBaudRate::RATE_57600, 4096);
+    reader->setDebugMode(false);
+    ReturnValue_t result = reader->initializeInterface(uartCookie);
+    if (result != OK) {
+      sif::warning << "UartTestClass::scexInit: Initializing SCEX reader "
+                      "UART IF failed"
+                   << std::endl;
+    }
+  }
+}
+
+void UartTestClass::scexPeriodic() {
+  using namespace std;
+  using namespace scex;
+
+  if (scexMode == ScexModes::SIMPLE) {
+    scexSimplePeriodic();
+  } else {
+    if (reader == nullptr) {
+      return;
+    }
+    if (not cmdSent) {
+      size_t len = 0;
+      prepareScexCmd(currCmd, false, cmdBuf.data(), &len);
+      reader->sendMessage(uartCookie, cmdBuf.data(), len);
+      cmdSent = true;
+      cmdDone = false;
+    }
+    if (cmdSent and not cmdDone) {
+      uint8_t* decodedPacket = nullptr;
+      size_t len = 0;
+      do {
+        ReturnValue_t result = reader->readReceivedMessage(uartCookie, &decodedPacket, &len);
+        if (len == 0) {
+          break;
+        }
+        ScexHelper helper;
+        const uint8_t* helperPtr = decodedPacket;
+        result = helper.deSerialize(&helperPtr, &len);
+        if (result == ScexHelper::INVALID_CRC) {
+          sif::warning << "UartTestClass::scexPeriodic: CRC invalid" << std::endl;
+        }
+        sif::info << helper << endl;
+
+        // ping
+        // if ping cmd
+        if (helper.getCmd() == PING) {
+          ofstream out("/tmp/scex-ping.bin", ofstream::binary);
+          if (out.bad()) {
+            sif::warning << "bad" << std::endl;
+          }
+          out << helper;
+        }
+        // fram
+        if (helper.getCmd() == FRAM) {
+          if (not fileNameSet) {
+            fileId = random_string(6);
+            fileName = "/tmp/scex-fram_" + fileId + ".bin";
+            fileNameSet = true;
+          }
+          if (helper.getPacketCounter() == 1) {
+            // countdown starten
+            finishCountdown.resetTimer();
+            ofstream out(fileName,
+                         ofstream::binary);  // neues file anlegen
+          } else {
+            ofstream out(fileName,
+                         ofstream::binary | ofstream::app);  // an bestehendes file appenden
+            out << helper;
+          }
+
+          if (finishCountdown.hasTimedOut()) {
+            triggerEvent(scex::EXPERIMENT_TIMEDOUT, currCmd, 0);
+            reader->finish();
+            sif::warning << "UartTestClass::scexPeriodic: Reader timeout" << endl;
+            cmdDone = true;
+            fileNameSet = false;
+          }
+        }
+
+        if (helper.getPacketCounter() == helper.getTotalPacketCounter()) {
+          reader->finish();
+          sif::info << "UartTestClass::scexPeriodic: Reader is finished" << endl;
+          cmdDone = true;
+          fileNameSet = false;
+          if (helper.getCmd() == scex::Cmds::PING) {
+            cmdSent = false;
+            fileNameSet = true;  // to not generate everytime new file
+          }
+        }
+      } while (len > 0);
+    }
+  }
+}
+
+void UartTestClass::scexSimpleInit() {
 #if defined(RASPBERRY_PI)
   std::string devname = "/dev/serial0";
 #else
@@ -135,8 +268,8 @@ void UartTestClass::scexInit() {
   /* Get file descriptor */
   serialPort = open(devname.c_str(), O_RDWR);
   if (serialPort < 0) {
-    sif::warning << "open call failed with error [" << errno << ", " << strerror(errno)
+    sif::warning << "UartTestClass::scexSimpleInit: Open call failed with error [" << errno << ", "
-                 << std::endl;
+                 << strerror(errno) << std::endl;
     return;
   }
   // Setting up UART parameters
@@ -152,74 +285,117 @@ void UartTestClass::scexInit() {
 
   // Non-blocking mode, read until either line is 0.1 second idle or maximum of 255 bytes are
   // received in one go
-  tty.c_cc[VTIME] = 1;   // In units of 0.1 seconds
+  tty.c_cc[VTIME] = 0;  // In units of 0.1 seconds
-  tty.c_cc[VMIN] = 255;  // Read up to 255 bytes
+  tty.c_cc[VMIN] = 0;   // Read up to 255 bytes
 
   // Q7S UART Lite has fixed baud rate. For other linux systems, set baud rate here.
 #if !defined(XIPHOS_Q7S)
   if (cfsetispeed(&tty, B57600) != 0) {
-    sif::warning << "UartTestClass::scexInit: Setting baud rate failed" << std::endl;
+    sif::warning << "UartTestClass::scexSimpleInit: Setting baud rate failed" << std::endl;
   }
 #endif
 
   if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
-    sif::warning << "tcsetattr call failed with error [" << errno << ", " << strerror(errno)
+    sif::warning << "UartTestClass::scexSimpleInit: tcsetattr call failed with error [" << errno
-                 << std::endl;
+                 << ", " << strerror(errno) << std::endl;
   }
   // Flush received and unread data
-  tcflush(serialPort, TCIFLUSH);
+  tcflush(serialPort, TCIOFLUSH);
 }
 
-void UartTestClass::scexPeriodic() {
+void UartTestClass::scexSimplePeriodic() {
-  sif::info << "UartTestClass::scexInit: Sending ping command to SCEX" << std::endl;
+  using namespace scex;
-  int result = prepareScexPing();
+  ReturnValue_t result = OK;
+  if (not cmdSent) {
+    // Flush received and unread data
+    tcflush(serialPort, TCIFLUSH);
+    uint8_t tmpCmdBuf[32] = {};
+    size_t len = 0;
+    sif::info << "UartTestClass::scexSimplePeriodic: Sending command to SCEX" << std::endl;
+    prepareScexCmd(currCmd, false, tmpCmdBuf, &len);
+    result = dleEncoder.encode(tmpCmdBuf, len, cmdBuf.data(), cmdBuf.size(), &encodedLen, true);
+    if (result != OK) {
+      sif::warning << "UartTestClass::scexSimplePeriodic: Encoding failed" << std::endl;
+      return;
+    }
     if (result != 0) {
       return;
     };
     size_t bytesWritten = write(serialPort, cmdBuf.data(), encodedLen);
     if (bytesWritten != encodedLen) {
-    sif::warning << "Sending ping command to solar experiment failed" << std::endl;
+      sif::warning
+          << "UartTestClass::scexSimplePeriodic: Sending command to solar experiment failed"
+          << std::endl;
     }
-
+    cmdSent = true;
+    cmdDone = false;
+  }
+  if (not cmdDone) {
     // Read back reply immediately
     int bytesRead = 0;
     do {
       bytesRead = read(serialPort, reinterpret_cast<void*>(recBuf.data()),
                        static_cast<unsigned int>(recBuf.size()));
-    if (bytesRead < 0) {
+      if (bytesRead == 0) {
-      sif::warning << "UartTestClass::performPeriodicAction: read call failed with error [" << errno
+        sif::warning << "UartTestClass::scexSimplePeriodic: Reading SCEX: Timeout or no bytes read"
+                     << std::endl;
+      } else if (bytesRead < 0) {
+        sif::warning << "UartTestClass::scexSimplePeriodic: read call failed with error [" << errno
                      << ", " << strerror(errno) << "]" << std::endl;
         break;
       } else if (bytesRead >= static_cast<int>(recBuf.size())) {
-      sif::debug << "UartTestClass::performPeriodicAction: recv buffer might not be large enough"
+        sif::debug << "UartTestClass::scexSimplePeriodic: recv buffer might not be large "
-                 << std::endl;
+                      "enough, bytes read:"
+                   << bytesRead << std::endl;
       } else if (bytesRead > 0) {
-      sif::info << "Received " << bytesRead
+        dleParser->passData(recBuf.data(), bytesRead);
-                << " bytes from the Solar Cell Experiment:" << std::endl;
+        if (currCmd == Cmds::PING) {
-      arrayprinter::print(recBuf.data(), bytesRead, OutputType::HEX, false);
+          cmdDone = true;
+          cmdSent = false;
+        }
       }
     } while (bytesRead > 0);
+  }
 }
 
-int UartTestClass::prepareScexPing() {
+int UartTestClass::prepareScexCmd(scex::Cmds cmd, bool tempCheck, uint8_t* cmdBuf, size_t* len) {
-  std::array<uint8_t, 128> tmpCmdBuf = {};
+  using namespace scex;
-  // Send ping command
+  // Send command
-  tmpCmdBuf[0] = scex::CMD_PING;
+  cmdBuf[0] = scex::createCmdByte(cmd, false);
   // These two fields are the packet counter and the total packet count. Those are 1 and 1 for each
   // telecommand so far
-  tmpCmdBuf[1] = 1;
+  cmdBuf[1] = 1;
-  tmpCmdBuf[2] = 1;
+  cmdBuf[2] = 1;
   uint16_t userDataLen = 0;
-  tmpCmdBuf[3] = (userDataLen >> 8) & 0xff;
+  cmdBuf[3] = (userDataLen >> 8) & 0xff;
-  tmpCmdBuf[4] = userDataLen & 0xff;
+  cmdBuf[4] = userDataLen & 0xff;
-  uint16_t crc = CRC::crc16ccitt(tmpCmdBuf.data(), 5);
+  uint16_t crc = CRC::crc16ccitt(cmdBuf, 5);
-  tmpCmdBuf[5] = (crc >> 8) & 0xff;
+  cmdBuf[5] = (crc >> 8) & 0xff;
-  tmpCmdBuf[6] = crc & 0xff;
+  cmdBuf[6] = crc & 0xff;
-  ReturnValue_t result =
+  *len = 7;
-      dleEncoder.encode(tmpCmdBuf.data(), 7, cmdBuf.data(), cmdBuf.size(), &encodedLen, true);
-  if (result != returnvalue::OK) {
-    sif::warning << "UartTestClass::scexInit: Encoding failed" << std::endl;
-    return -1;
-  }
   return 0;
 }
+
+void UartTestClass::handleFoundDlePacket(uint8_t* packet, size_t len) {
+  sif::info << "UartTestClass::handleFoundDlePacket: Detected DLE encoded packet with decoded size "
+            << len << std::endl;
+}
+
+std::string UartTestClass::random_string(std::string::size_type length) {
+  static auto& chrs =
+      "0123456789"
+      "abcdefghijklmnopqrstuvwxyz"
+      "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+  thread_local static std::mt19937 rg{std::random_device{}()};
+  thread_local static std::uniform_int_distribution<std::string::size_type> pick(0,
+                                                                                 sizeof(chrs) - 2);
+
+  std::string s;
+
+  s.reserve(length);
+
+  while (length--) s += chrs[pick(rg)];
+
+  return s;
+}

linux/boardtest/UartTestClass.h

@@ -1,14 +1,22 @@
 #ifndef LINUX_BOARDTEST_UARTTESTCLASS_H_
 #define LINUX_BOARDTEST_UARTTESTCLASS_H_
 
+#include <fsfw/container/SimpleRingBuffer.h>
 #include <fsfw/globalfunctions/DleEncoder.h>
+#include <fsfw/globalfunctions/DleParser.h>
+#include <fsfw/timemanager/Countdown.h>
+#include <fsfw_hal/linux/uart/UartCookie.h>
 #include <termios.h>  // Contains POSIX terminal control definitions
 
 #include <array>
 
 #include "lwgps/lwgps.h"
+#include "mission/devices/devicedefinitions/ScexDefinitions.h"
 #include "test/testtasks/TestTask.h"
 
+class ScexUartReader;
+class ScexDleParser;
+
 class UartTestClass : public TestTask {
  public:
   UartTestClass(object_id_t objectId);
@@ -24,20 +32,42 @@ class UartTestClass : public TestTask {
     SCEX
   };
 
+  enum ScexModes { SIMPLE, READER_TASK } scexMode;
+
   void gpsInit();
   void gpsPeriodic();
 
   void scexInit();
   void scexPeriodic();
-  int prepareScexPing();
+  int prepareScexCmd(scex::Cmds cmd, bool tempCheck, uint8_t* cmdBuf, size_t* len);
+
+  void scexSimplePeriodic();
+  void scexSimpleInit();
+
+  static void foundDlePacketHandler(const DleParser::Context& ctx);
+  void handleFoundDlePacket(uint8_t* packet, size_t len);
+  std::string random_string(std::string::size_type length);
+
+  std::string fileId = "";
+  std::string fileName = "";
+  bool fileNameSet = false;
+  Countdown finishCountdown = Countdown(180 * 1000);
+  bool cmdSent = false;
+  bool cmdDone = false;
+  scex::Cmds currCmd = scex::Cmds::PING;
   TestModes mode = TestModes::GPS;
   DleEncoder dleEncoder = DleEncoder();
+  UartCookie* uartCookie = nullptr;
   size_t encodedLen = 0;
   lwgps_t gpsData = {};
   struct termios tty = {};
   int serialPort = 0;
+  bool startFound = false;
+  ScexUartReader* reader = nullptr;
   std::array<uint8_t, 64> cmdBuf = {};
   std::array<uint8_t, 4096> recBuf = {};
+  ScexDleParser* dleParser;
+  scex::Cmds cmdHelper = scex::Cmds::INVALID;
   uint8_t recvCnt = 0;
 };
 

linux/devices/CMakeLists.txt

@@ -2,7 +2,9 @@ if(EIVE_BUILD_GPSD_GPS_HANDLER)
   target_sources(${OBSW_NAME} PRIVATE GPSHyperionLinuxController.cpp)
 endif()
 
-target_sources(${OBSW_NAME} PRIVATE Max31865RtdLowlevelHandler.cpp)
+target_sources(
+  ${OBSW_NAME} PRIVATE Max31865RtdLowlevelHandler.cpp ScexUartReader.cpp
+                       ScexDleParser.cpp ScexHelper.cpp)
 
 add_subdirectory(ploc)
 add_subdirectory(startracker)

linux/devices/GPSHyperionLinuxController.cpp

@@ -18,9 +18,7 @@
 
 GPSHyperionLinuxController::GPSHyperionLinuxController(object_id_t objectId, object_id_t parentId,
                                                        bool debugHyperionGps)
-    : ExtendedControllerBase(objectId, objects::NO_OBJECT),
+    : ExtendedControllerBase(objectId), gpsSet(this), debugHyperionGps(debugHyperionGps) {
-      gpsSet(this),
-      debugHyperionGps(debugHyperionGps) {
   timeUpdateCd.resetTimer();
 }
 

linux/devices/GPSHyperionLinuxController.h

@@ -1,7 +1,7 @@
 #ifndef MISSION_DEVICES_GPSHYPERIONHANDLER_H_
 #define MISSION_DEVICES_GPSHYPERIONHANDLER_H_
 
-#include "commonSubsystemIds.h"
+#include "eive/eventSubsystemIds.h"
 #include "fsfw/FSFW.h"
 #include "fsfw/controller/ExtendedControllerBase.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"

linux/devices/Max31865RtdLowlevelHandler.cpp

@@ -50,7 +50,7 @@ ReturnValue_t Max31865RtdReader::performOperation(uint8_t operationCode) {
 }
 
 bool Max31865RtdReader::rtdIsActive(uint8_t idx) {
-  if (rtds[idx]->on and rtds[idx]->active and rtds[idx]->configured) {
+  if (rtds[idx]->on and rtds[idx]->db.active and rtds[idx]->db.configured) {
     return true;
   }
   return false;
@@ -69,7 +69,7 @@ bool Max31865RtdReader::periodicInitHandling() {
     if (rtd == nullptr) {
       continue;
     }
-    if ((rtd->on or rtd->active) and not rtd->configured and rtd->cd.hasTimedOut()) {
+    if ((rtd->on or rtd->db.active) and not rtd->db.configured and rtd->cd.hasTimedOut()) {
       ManualCsLockWrapper mg(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
       if (mg.lockResult != returnvalue::OK or mg.gpioResult != returnvalue::OK) {
         sif::error << "Max31865RtdReader::periodicInitHandling: Manual CS lock failed" << std::endl;
@@ -95,13 +95,7 @@ bool Max31865RtdReader::periodicInitHandling() {
       if (result != returnvalue::OK) {
         handleSpiError(rtd, result, "clearFaultStatus");
       }
-      rtd->configured = true;
       rtd->db.configured = true;
-      if (rtd->active) {
-        rtd->db.active = true;
-      }
-    }
-    if (rtd->active and rtd->configured and not rtd->db.active) {
       rtd->db.active = true;
     }
   }
@@ -241,8 +235,8 @@ ReturnValue_t Max31865RtdReader::sendMessage(CookieIF* cookie, const uint8_t* se
         rtdCookie->cd.setTimeout(MAX31865::WARMUP_MS);
         rtdCookie->cd.resetTimer();
         rtdCookie->on = true;
-        rtdCookie->active = false;
+        rtdCookie->db.active = false;
-        rtdCookie->configured = false;
+        rtdCookie->db.configured = false;
         if (sendLen == 5) {
           thresholdHandler(rtdCookie, sendData);
         }
@@ -254,10 +248,10 @@ ReturnValue_t Max31865RtdReader::sendMessage(CookieIF* cookie, const uint8_t* se
         rtdCookie->cd.setTimeout(MAX31865::WARMUP_MS);
         rtdCookie->cd.resetTimer();
         rtdCookie->on = true;
-        rtdCookie->active = true;
+        rtdCookie->db.active = true;
-        rtdCookie->configured = false;
+        rtdCookie->db.configured = false;
       } else {
-        rtdCookie->active = true;
+        rtdCookie->db.active = true;
       }
       if (sendLen == 5) {
         thresholdHandler(rtdCookie, sendData);
@@ -266,8 +260,8 @@ ReturnValue_t Max31865RtdReader::sendMessage(CookieIF* cookie, const uint8_t* se
     }
     case (EiveMax31855::RtdCommands::OFF): {
       rtdCookie->on = false;
-      rtdCookie->active = false;
+      rtdCookie->db.active = false;
-      rtdCookie->configured = false;
+      rtdCookie->db.configured = false;
       break;
     }
     case (EiveMax31855::RtdCommands::HIGH_TRESHOLD): {

linux/devices/Max31865RtdLowlevelHandler.h

@@ -23,8 +23,6 @@ struct Max31865ReaderCookie : public CookieIF {
   Countdown cd = Countdown(MAX31865::WARMUP_MS);
 
   bool on = false;
-  bool configured = false;
-  bool active = false;
   bool writeLowThreshold = false;
   bool writeHighThreshold = false;
   uint16_t lowThreshold = 0;

linux/devices/ScexDleParser.cpp

@@ -0,0 +1,7 @@
+#include "ScexDleParser.h"
+
+ScexDleParser::ScexDleParser(SimpleRingBuffer &decodeRingBuf, DleEncoder &decoder,
+                             BufPair encodedBuf, BufPair decodedBuf)
+    : DleParser(decodeRingBuf, decoder, encodedBuf, decodedBuf){};
+
+ScexDleParser::~ScexDleParser(){};

linux/devices/ScexDleParser.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <fsfw/globalfunctions/DleParser.h>
+
+class ScexDleParser : public DleParser {
+ public:
+  ScexDleParser(SimpleRingBuffer &decodeRingBuf, DleEncoder &decoder, BufPair encodedBuf,
+                BufPair decodedBuf);
+
+  virtual ~ScexDleParser();
+
+ private:
+};

linux/devices/ScexHelper.cpp

@@ -0,0 +1,86 @@
+#include "ScexHelper.h"
+
+#include <fsfw/globalfunctions/CRC.h>
+
+#include "fsfw/serviceinterface.h"
+
+using namespace returnvalue;
+
+ScexHelper::ScexHelper() {}
+
+ReturnValue_t ScexHelper::serialize(uint8_t** buffer, size_t* size, size_t maxSize,
+                                    Endianness streamEndianness) const {
+  return FAILED;
+}
+
+size_t ScexHelper::getSerializedSize() const { return totalPacketLen; }
+
+ReturnValue_t ScexHelper::deSerialize(const uint8_t** buffer, size_t* size,
+                                      Endianness streamEndianness) {
+  if (buffer == nullptr or size == nullptr) {
+    return FAILED;
+  }
+  if (*size < 7) {
+    return STREAM_TOO_SHORT;
+  }
+  start = *buffer;
+  cmdByteRaw = **buffer;
+  cmd = static_cast<scex::Cmds>((cmdByteRaw >> 1) & 0b11111);
+
+  *buffer += 1;
+  packetCounter = **buffer;
+
+  *buffer += 1;
+  totalPacketCounter = **buffer;
+
+  *buffer += 1;
+  payloadLen = (**buffer << 8) | *(*buffer + 1);
+
+  *buffer += 2;
+  payloadStart = *buffer;
+  totalPacketLen = payloadLen + scex::HEADER_LEN + scex::CRC_LEN;
+  if (totalPacketLen >= *size) {
+    return STREAM_TOO_SHORT;
+  }
+  *buffer += payloadLen;
+  crc = (**buffer << 8) | *(*buffer + 1);
+  if (CRC::crc16ccitt(start, totalPacketLen) != 0) {
+    return INVALID_CRC;
+  }
+  return OK;
+}
+
+scex::Cmds ScexHelper::getCmd() const { return cmd; }
+
+uint8_t ScexHelper::getCmdByteRaw() const { return cmdByteRaw; }
+
+uint16_t ScexHelper::getCrc() const { return crc; }
+
+size_t ScexHelper::getExpectedPacketLen() const { return totalPacketLen; }
+
+uint8_t ScexHelper::getPacketCounter() const { return packetCounter; }
+
+uint16_t ScexHelper::getPayloadLen() const { return payloadLen; }
+
+const uint8_t* ScexHelper::getStart() const { return start; }
+
+uint8_t ScexHelper::getTotalPacketCounter() const { return totalPacketCounter; }
+
+std::ostream& operator<<(std::ostream& os, const ScexHelper& h) {
+  using namespace std;
+  sif::info << "Command Byte Raw: 0x" << std::setw(2) << std::setfill('0') << std::hex
+            << (int)h.cmdByteRaw << " | Command: 0x" << std::setw(2) << std::setfill('0')
+            << std::hex << static_cast<int>(h.cmd) << std::dec << std::endl;
+  sif::info << "PacketCounter: " << h.packetCounter << endl;
+  sif::info << "TotalPacketCount: " << h.totalPacketCounter << endl;
+  sif::info << "PayloadLength: " << h.payloadLen << endl;
+  sif::info << "TotalPacketLength: " << h.totalPacketLen;
+
+  return os;
+}
+
+std::ofstream& operator<<(std::ofstream& of, const ScexHelper& h) {
+  of.write(reinterpret_cast<const char*>(h.start), h.getSerializedSize());
+
+  return of;
+}

linux/devices/ScexHelper.h

@@ -0,0 +1,46 @@
+#ifndef LINUX_DEVICES_SCEXHELPER_H_
+#define LINUX_DEVICES_SCEXHELPER_H_
+#include <fsfw/serialize/SerializeIF.h>
+#include <mission/devices/devicedefinitions/ScexDefinitions.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+
+class ScexHelper : public SerializeIF {
+ public:
+  static const ReturnValue_t INVALID_CRC = returnvalue::makeCode(0, 2);
+
+  ScexHelper();
+  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                          Endianness streamEndianness) const override;
+
+  size_t getSerializedSize() const override;
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                            Endianness streamEndianness = Endianness::BIG) override;
+  friend std::ostream &operator<<(std::ostream &os, const ScexHelper &h);
+  friend std::ofstream &operator<<(std::ofstream &os, const ScexHelper &h);
+
+  scex::Cmds getCmd() const;
+  uint8_t getCmdByteRaw() const;
+  uint16_t getCrc() const;
+  size_t getExpectedPacketLen() const;
+  uint8_t getPacketCounter() const;
+  uint16_t getPayloadLen() const;
+  const uint8_t *getStart() const;
+  uint8_t getTotalPacketCounter() const;
+
+ private:
+  const uint8_t *start = nullptr;
+  uint16_t crc = 0;
+  uint8_t cmdByteRaw = 0;
+  scex::Cmds cmd = scex::Cmds::INVALID;
+  int packetCounter = 0;
+  int totalPacketCounter = 0;
+  uint16_t payloadLen = 0;
+  const uint8_t *payloadStart = 0;
+  size_t totalPacketLen = 0;
+};
+
+#endif /* LINUX_DEVICES_SCEXHELPER_H_ */

linux/devices/ScexUartReader.cpp

@@ -0,0 +1,233 @@
+#include "ScexUartReader.h"
+
+#include <fcntl.h>  // Contains file controls like O_RDWR
+#include <fsfw/globalfunctions/arrayprinter.h>
+#include <fsfw/ipc/MutexFactory.h>
+#include <fsfw/ipc/MutexGuard.h>
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw_hal/linux/uart/UartCookie.h>
+#include <unistd.h>  // write(), read(), close()
+
+#include <cerrno>  // Error integer and strerror() function
+#include <iostream>
+
+#include "OBSWConfig.h"
+
+using namespace returnvalue;
+
+ScexUartReader::ScexUartReader(object_id_t objectId)
+    : SystemObject(objectId),
+      decodeRingBuf(4096, true),
+      ipcRingBuf(200 * 2048, true),
+      ipcQueue(200),
+      dleParser(decodeRingBuf, dleEncoder, {encodedBuf.data(), encodedBuf.size()},
+                {decodedBuf.data(), decodedBuf.size()}) {
+  semaphore = SemaphoreFactory::instance()->createBinarySemaphore();
+  semaphore->acquire();
+  lock = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t ScexUartReader::performOperation(uint8_t operationCode) {
+  lock->lockMutex();
+  state = States::IDLE;
+  lock->unlockMutex();
+  while (true) {
+    semaphore->acquire();
+    int bytesRead = 0;
+    // debugMode = true;
+    while (true) {
+      bytesRead = read(serialPort, reinterpret_cast<void *>(recBuf.data()),
+                       static_cast<unsigned int>(recBuf.size()));
+      if (bytesRead == 0) {
+        {
+          MutexGuard mg(lock);
+          if (state == States::FINISH) {
+            dleParser.reset();
+            // Flush received and unread data
+            tcflush(serialPort, TCIOFLUSH);
+            state = States::IDLE;
+            break;
+          }
+        }
+        ReturnValue_t result = returnvalue::OK;
+        // Can be used to read frame, parity and overrun errors
+        // serial_icounter_struct icounter{};
+        // uart::readCountersAndErrors(serialPort, icounter);
+        while (result != DleParser::NO_PACKET_FOUND) {
+          result = tryDleParsing();
+        }
+
+        TaskFactory::delayTask(400);
+      } else if (bytesRead < 0) {
+        sif::warning << "ScexUartReader::performOperation: read call failed with error [" << errno
+                     << ", " << strerror(errno) << "]" << std::endl;
+        break;
+      } else if (bytesRead >= static_cast<int>(recBuf.size())) {
+        sif::error << "ScexUartReader::performOperation: Receive buffer too small for " << bytesRead
+                   << " bytes" << std::endl;
+      } else if (bytesRead > 0) {
+        if (debugMode) {
+          sif::info << "Received " << bytesRead
+                    << " bytes from the Solar Cell Experiment:" << std::endl;
+        }
+        ReturnValue_t result = dleParser.passData(recBuf.data(), bytesRead);
+        if (result != OK) {
+          sif::warning << "ScexUartReader::performOperation: Passing data to DLE parser failed"
+                       << std::endl;
+        }
+        result = tryDleParsing();
+      }
+    };
+  }
+  return OK;
+}
+
+ReturnValue_t ScexUartReader::initializeInterface(CookieIF *cookie) {
+  UartCookie *uartCookie = dynamic_cast<UartCookie *>(cookie);
+  if (uartCookie == nullptr) {
+    return FAILED;
+  }
+  std::string devname = uartCookie->getDeviceFile();
+  /* Get file descriptor */
+  serialPort = open(devname.c_str(), O_RDWR);
+  if (serialPort < 0) {
+    sif::warning << "ScexUartReader::initializeInterface: open call failed with error [" << errno
+                 << ", " << strerror(errno) << std::endl;
+    return FAILED;
+  }
+  // Setting up UART parameters
+  tty.c_cflag &= ~PARENB;  // Clear parity bit
+  if (uartCookie->getStopBits() == StopBits::TWO_STOP_BITS) {
+    // Use two stop bits
+    tty.c_cflag |= CSTOPB;
+  } else {
+    // Clear stop field, only one stop bit used in communication
+    tty.c_cflag &= ~CSTOPB;
+  }
+
+  tty.c_cflag &= ~CSIZE;          // Clear all the size bits
+  tty.c_cflag |= CS8;             // 8 bits per byte
+  tty.c_cflag &= ~CRTSCTS;        // Disable RTS/CTS hardware flow control
+  tty.c_cflag |= CREAD | CLOCAL;  // Turn on READ & ignore ctrl lines (CLOCAL = 1)
+
+  // Use non-canonical mode and clear echo flag
+  tty.c_lflag &= ~(ICANON | ECHO);
+
+  // Non-blocking mode, use polling
+  tty.c_cc[VTIME] = 0;
+  tty.c_cc[VMIN] = 0;
+
+  uart::setBaudrate(tty, uartCookie->getBaudrate());
+  if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
+    sif::warning << "ScexUartReader::initializeInterface: tcsetattr call failed with error ["
+                 << errno << ", " << strerror(errno) << std::endl;
+  }
+  // Flush received and unread data
+  tcflush(serialPort, TCIOFLUSH);
+  return OK;
+}
+
+ReturnValue_t ScexUartReader::sendMessage(CookieIF *cookie, const uint8_t *sendData,
+                                          size_t sendLen) {
+  ReturnValue_t result;
+  if (sendData == nullptr or sendLen == 0) {
+    return FAILED;
+  }
+  lock->lockMutex();
+  if (state == States::NOT_READY or state == States::RUNNING) {
+    lock->unlockMutex();
+    return FAILED;
+  }
+  tcflush(serialPort, TCIFLUSH);
+  state = States::RUNNING;
+  lock->unlockMutex();
+
+  result = semaphore->release();
+  if (result != OK) {
+    std::cout << "ScexUartReader::sendMessage: Releasing semaphore failed" << std::endl;
+  }
+  size_t encodedLen = 0;
+  result = dleEncoder.encode(sendData, sendLen, cmdbuf.data(), cmdbuf.size(), &encodedLen, true);
+  if (result != OK) {
+    sif::warning << "ScexUartReader::sendMessage: Encoding failed" << std::endl;
+    return FAILED;
+  }
+  size_t bytesWritten = write(serialPort, cmdbuf.data(), encodedLen);
+  if (bytesWritten != encodedLen) {
+    sif::warning << "ScexUartReader::sendMessage: Sending ping command to solar experiment failed"
+                 << std::endl;
+    return FAILED;
+  }
+
+  return OK;
+}
+
+ReturnValue_t ScexUartReader::getSendSuccess(CookieIF *cookie) { return OK; }
+
+ReturnValue_t ScexUartReader::requestReceiveMessage(CookieIF *cookie, size_t requestLen) {
+  return OK;
+}
+
+void ScexUartReader::setDebugMode(bool enable) { this->debugMode = enable; }
+
+ReturnValue_t ScexUartReader::finish() {
+  MutexGuard mg(lock);
+  if (state == States::IDLE) {
+    return FAILED;
+  }
+  state = States::FINISH;
+  return OK;
+}
+
+void ScexUartReader::handleFoundDlePacket(uint8_t *packet, size_t len) {
+  MutexGuard mg(lock);
+  ReturnValue_t result = ipcQueue.insert(len);
+  if (result != OK) {
+    sif::warning << "ScexUartReader::handleFoundDlePacket: IPCQueue error" << std::endl;
+  }
+  result = ipcRingBuf.writeData(packet, len);
+  if (result != OK) {
+    sif::warning << "ScexUartReader::handleFoundDlePacket: IPCRingBuf error" << std::endl;
+  }
+}
+
+ReturnValue_t ScexUartReader::tryDleParsing() {
+  size_t bytesRead = 0;
+  ReturnValue_t result = dleParser.parseRingBuf(bytesRead);
+  if (result == returnvalue::OK) {
+    // Packet found, advance read pointer.
+    auto &decodedPacket = dleParser.getContext().decodedPacket;
+    handleFoundDlePacket(decodedPacket.first, decodedPacket.second);
+    dleParser.confirmBytesRead(bytesRead);
+  } else if (result != DleParser::NO_PACKET_FOUND) {
+    sif::warning << "ScexUartReader::performOperation: Possible packet loss" << std::endl;
+    // Markers found at wrong place
+    // which might be a hint for a possibly lost packet.
+    dleParser.defaultErrorHandler();
+    dleParser.confirmBytesRead(bytesRead);
+  }
+  return result;
+}
+
+void ScexUartReader::reset() {
+  lock->lockMutex();
+  state = States::FINISH;
+  lock->unlockMutex();
+}
+
+ReturnValue_t ScexUartReader::readReceivedMessage(CookieIF *cookie, uint8_t **buffer,
+                                                  size_t *size) {
+  MutexGuard mg(lock);
+  if (ipcQueue.empty()) {
+    *size = 0;
+    return OK;
+  }
+  ipcQueue.retrieve(size);
+  *buffer = ipcBuffer.data();
+  ReturnValue_t result = ipcRingBuf.readData(ipcBuffer.data(), *size, true);
+  if (result != OK) {
+    sif::warning << "ScexUartReader::readReceivedMessage: Reading RingBuffer failed" << std::endl;
+  }
+  return OK;
+}

linux/devices/ScexUartReader.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <fsfw/container/DynamicFIFO.h>
+#include <fsfw/container/SimpleRingBuffer.h>
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/globalfunctions/DleEncoder.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+#include <fsfw/timemanager/Countdown.h>
+#include <linux/devices/ScexDleParser.h>
+#include <termios.h>  // Contains POSIX terminal control definitions
+
+class SemaphoreIF;
+class MutexIF;
+
+class ScexUartReader : public SystemObject,
+                       public ExecutableObjectIF,
+                       public DeviceCommunicationIF {
+  friend class UartTestClass;
+
+ public:
+  enum class States { NOT_READY, IDLE, RUNNING, FINISH };
+  ScexUartReader(object_id_t objectId);
+
+  void reset();
+  ReturnValue_t finish();
+  void setDebugMode(bool enable);
+
+ private:
+  SemaphoreIF *semaphore;
+  bool debugMode = false;
+  MutexIF *lock;
+  int serialPort = 0;
+  States state = States::IDLE;
+  struct termios tty = {};
+  bool doFinish = false;
+  DleEncoder dleEncoder = DleEncoder();
+  SimpleRingBuffer decodeRingBuf;
+
+  std::array<uint8_t, 256> cmdbuf = {};
+  std::array<uint8_t, 4096> recBuf = {};
+  std::array<uint8_t, 4096> encodedBuf = {};
+  std::array<uint8_t, 4096> decodedBuf = {};
+  std::array<uint8_t, 4096> ipcBuffer = {};
+  SimpleRingBuffer ipcRingBuf;
+  DynamicFIFO<size_t> ipcQueue;
+  ScexDleParser dleParser;
+
+  static void foundDlePacketHandler(const DleParser::Context &ctx);
+  void handleFoundDlePacket(uint8_t *packet, size_t len);
+  ReturnValue_t tryDleParsing();
+
+  ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+  // DeviceCommunicationIF implementation
+  ReturnValue_t initializeInterface(CookieIF *cookie) override;
+  ReturnValue_t sendMessage(CookieIF *cookie, const uint8_t *sendData, size_t sendLen) override;
+  ReturnValue_t getSendSuccess(CookieIF *cookie) override;
+  ReturnValue_t requestReceiveMessage(CookieIF *cookie, size_t requestLen) override;
+  ReturnValue_t readReceivedMessage(CookieIF *cookie, uint8_t **buffer, size_t *size) override;
+};

linux/devices/ploc/PlocMPSoCHelper.cpp

@@ -5,7 +5,7 @@
 
 #include "OBSWConfig.h"
 #ifdef XIPHOS_Q7S
-#include "bsp_q7s/memory/FilesystemHelper.h"
+#include "bsp_q7s/fs/FilesystemHelper.h"
 #endif
 
 #include "mission/utility/Timestamp.h"

linux/devices/ploc/PlocMPSoCHelper.h

@@ -12,7 +12,7 @@
 #include "fsfw_hal/linux/uart/UartComIF.h"
 #include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #ifdef XIPHOS_Q7S
-#include "bsp_q7s/memory/SdCardManager.h"
+#include "bsp_q7s/fs/SdCardManager.h"
 #endif
 
 /**

linux/devices/ploc/PlocMemoryDumper.h

@@ -5,7 +5,7 @@
 #include <linux/devices/devicedefinitions/PlocSupervisorDefinitions.h>
 
 #include "OBSWConfig.h"
-#include "bsp_q7s/memory/SdCardManager.h"
+#include "bsp_q7s/fs/SdCardManager.h"
 #include "fsfw/action/ActionHelper.h"
 #include "fsfw/action/CommandActionHelper.h"
 #include "fsfw/action/CommandsActionsIF.h"

linux/devices/ploc/PlocSupervisorHandler.cpp

@@ -1,6 +1,6 @@
 #include "PlocSupervisorHandler.h"
 
-#include <fsfw/memory/HasFileSystemIF.h>
+#include <fsfw/filesystem/HasFileSystemIF.h>
 
 #include <filesystem>
 #include <fstream>
@@ -1917,6 +1917,11 @@ ReturnValue_t PlocSupervisorHandler::checkMramPacketApid() {
 }
 
 ReturnValue_t PlocSupervisorHandler::handleMramDumpFile(DeviceCommandId_t id) {
+#ifdef XIPHOS_Q7S
+  if (not sdcMan->getActiveSdCard()) {
+    return HasFileSystemIF::FILESYSTEM_INACTIVE;
+  }
+#endif
   ReturnValue_t result = returnvalue::OK;
   uint16_t packetLen = readSpacePacketLength(spacePacketBuffer);
   uint8_t sequenceFlags = readSequenceFlags(spacePacketBuffer);

linux/devices/ploc/PlocSupervisorHandler.h

@@ -3,7 +3,7 @@
 
 #include "OBSWConfig.h"
 #include "PlocSupvHelper.h"
-#include "bsp_q7s/memory/SdCardManager.h"
+#include "bsp_q7s/fs/SdCardManager.h"
 #include "devices/powerSwitcherList.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #include "fsfw/timemanager/Countdown.h"

linux/devices/ploc/PlocSupvHelper.cpp

@@ -1,6 +1,7 @@
 #include "PlocSupvHelper.h"
 
 #include <etl/crc16_ccitt.h>
+#include <fsfw/filesystem/HasFileSystemIF.h>
 
 #include <cmath>
 #include <filesystem>
@@ -8,8 +9,8 @@
 
 #include "OBSWConfig.h"
 #ifdef XIPHOS_Q7S
-#include "bsp_q7s/memory/FilesystemHelper.h"
+#include "bsp_q7s/fs/FilesystemHelper.h"
-#include "bsp_q7s/memory/SdCardManager.h"
+#include "bsp_q7s/fs/SdCardManager.h"
 #endif
 
 #include "fsfw/tasks/TaskFactory.h"
@@ -748,6 +749,11 @@ uint32_t PlocSupvHelper::getFileSize(std::string filename) {
 
 ReturnValue_t PlocSupvHelper::handleEventBufferReception(ploc::SpTmReader& reader) {
   ReturnValue_t result = returnvalue::OK;
+#ifdef XIPHOS_Q7S
+  if (not sdcMan->getActiveSdCard()) {
+    return HasFileSystemIF::FILESYSTEM_INACTIVE;
+  }
+#endif
   std::string filename = Filenaming::generateAbsoluteFilename(
       eventBufferReq.path, eventBufferReq.filename, timestamping);
   std::ofstream file(filename, std::ios_base::app | std::ios_base::out);

linux/devices/ploc/PlocSupvHelper.h

@@ -13,7 +13,7 @@
 #include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"
 
 #ifdef XIPHOS_Q7S
-#include "bsp_q7s/memory/SdCardManager.h"
+#include "bsp_q7s/fs/SdCardManager.h"
 #endif
 
 /**

linux/devices/startracker/StarTrackerHandler.cpp

@@ -240,13 +240,12 @@ void StarTrackerHandler::doStartUp() {
       // the device handler's submode to the star tracker's mode
       return;
     case StartupState::DONE:
-      submode = SUBMODE_BOOTLOADER;
       startupState = StartupState::IDLE;
       break;
     default:
       return;
   }
-  setMode(_MODE_TO_ON);
+  setMode(_MODE_TO_ON, SUBMODE_BOOTLOADER);
 }
 
 void StarTrackerHandler::doShutDown() {
@@ -654,7 +653,7 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
 }
 
 ReturnValue_t StarTrackerHandler::isModeCombinationValid(Mode_t mode, Submode_t submode) {
-  if (this->mode == MODE_NORMAL && mode == MODE_ON) {
+  if (getMode() == MODE_NORMAL && mode == MODE_ON) {
     return TRANS_NOT_ALLOWED;
   }
   switch (mode) {
@@ -678,7 +677,7 @@ ReturnValue_t StarTrackerHandler::isModeCombinationValid(Mode_t mode, Submode_t
 }
 
 void StarTrackerHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
-  switch (mode) {
+  switch (getMode()) {
     case _MODE_TO_ON:
       doOnTransition(subModeFrom);
       break;
@@ -698,17 +697,18 @@ void StarTrackerHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
 }
 
 void StarTrackerHandler::doOnTransition(Submode_t subModeFrom) {
-  if (submode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_FIRMWARE) {
+  uint8_t dhbSubmode = getSubmode();
+  if (dhbSubmode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_FIRMWARE) {
     bootBootloader();
-  } else if (submode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_FIRMWARE) {
+  } else if (dhbSubmode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_FIRMWARE) {
     setMode(MODE_ON);
-  } else if (submode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_BOOTLOADER) {
+  } else if (dhbSubmode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_BOOTLOADER) {
     bootFirmware(MODE_ON);
-  } else if (submode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_BOOTLOADER) {
+  } else if (dhbSubmode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_BOOTLOADER) {
     setMode(MODE_ON);
-  } else if (submode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_NONE) {
+  } else if (dhbSubmode == SUBMODE_BOOTLOADER && subModeFrom == SUBMODE_NONE) {
     setMode(MODE_ON);
-  } else if (submode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_NONE) {
+  } else if (dhbSubmode == SUBMODE_FIRMWARE && subModeFrom == SUBMODE_NONE) {
     setMode(MODE_ON);
   }
 }
@@ -2067,13 +2067,13 @@ ReturnValue_t StarTrackerHandler::checkCommand(ActionId_t actionId) {
     case startracker::REQ_SUBSCRIPTION:
     case startracker::REQ_LOG_SUBSCRIPTION:
     case startracker::REQ_DEBUG_CAMERA:
-      if (not(mode == MODE_ON && submode == startracker::Program::FIRMWARE)) {
+      if (not(getMode() == MODE_ON && getSubmode() == startracker::Program::FIRMWARE)) {
         return STARTRACKER_RUNNING_BOOTLOADER;
       }
       break;
     case startracker::FIRMWARE_UPDATE:
     case startracker::FLASH_READ:
-      if (not(mode == MODE_ON && submode == startracker::Program::BOOTLOADER)) {
+      if (not(getMode() == MODE_ON && getSubmode() == startracker::Program::BOOTLOADER)) {
         return STARTRACKER_RUNNING_FIRMWARE;
       }
       break;

linux/devices/startracker/StrHelper.cpp

@@ -1,9 +1,12 @@
 #include "StrHelper.h"
 
+#include <fsfw/filesystem/HasFileSystemIF.h>
+
 #include <filesystem>
 #include <fstream>
 
 #include "OBSWConfig.h"
+#include "eive/definitions.h"
 #include "fsfw/timemanager/Countdown.h"
 #include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
 #include "mission/utility/Filenaming.h"
@@ -175,6 +178,11 @@ void StrHelper::disableTimestamping() { timestamping = false; }
 void StrHelper::enableTimestamping() { timestamping = true; }
 
 ReturnValue_t StrHelper::performImageDownload() {
+#ifdef XIPHOS_Q7S
+  if (not sdcMan->getActiveSdCard()) {
+    return HasFileSystemIF::FILESYSTEM_INACTIVE;
+  }
+#endif
   ReturnValue_t result;
 #if OBSW_DEBUG_STARTRACKER == 1
   ProgressPrinter progressPrinter("Image download", ImageDownload::LAST_POSITION);
@@ -243,6 +251,11 @@ ReturnValue_t StrHelper::performImageUpload() {
   uint32_t imageSize = 0;
   struct UploadActionRequest uploadReq;
   uploadReq.position = 0;
+#ifdef XIPHOS_Q7S
+  if (not sdcMan->getActiveSdCard()) {
+    return HasFileSystemIF::FILESYSTEM_INACTIVE;
+  }
+#endif
   std::memset(&uploadReq.data, 0, sizeof(uploadReq.data));
   if (not std::filesystem::exists(uploadImage.uploadFile)) {
     triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast<uint32_t>(internalState));
@@ -314,6 +327,11 @@ ReturnValue_t StrHelper::performFirmwareUpdate() {
 }
 
 ReturnValue_t StrHelper::performFlashWrite() {
+#ifdef XIPHOS_Q7S
+  if (not sdcMan->getActiveSdCard()) {
+    return HasFileSystemIF::FILESYSTEM_INACTIVE;
+  }
+#endif
   ReturnValue_t result = returnvalue::OK;
   uint32_t size = 0;
   uint32_t bytesWritten = 0;
@@ -393,6 +411,11 @@ ReturnValue_t StrHelper::performFlashWrite() {
 }
 
 ReturnValue_t StrHelper::performFlashRead() {
+#ifdef XIPHOS_Q7S
+  if (not sdcMan->getActiveSdCard()) {
+    return HasFileSystemIF::FILESYSTEM_INACTIVE;
+  }
+#endif
   ReturnValue_t result;
 #if OBSW_DEBUG_STARTRACKER == 1
   ProgressPrinter progressPrinter("Flash read", flashRead.size);
@@ -541,15 +564,14 @@ ReturnValue_t StrHelper::checkReplyPosition(uint32_t expectedPosition) {
 
 #ifdef XIPHOS_Q7S
 ReturnValue_t StrHelper::checkPath(std::string name) {
-  if (name.substr(0, sizeof(SdCardManager::SD_0_MOUNT_POINT)) ==
+  if (name.substr(0, sizeof(config::SD_0_MOUNT_POINT)) == std::string(config::SD_0_MOUNT_POINT)) {
-      std::string(SdCardManager::SD_0_MOUNT_POINT)) {
+    if (!sdcMan->isSdCardUsable(sd::SLOT_0)) {
-    if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
       sif::warning << "StrHelper::checkPath: SD card 0 not mounted" << std::endl;
       return SD_NOT_MOUNTED;
     }
-  } else if (name.substr(0, sizeof(SdCardManager::SD_1_MOUNT_POINT)) ==
+  } else if (name.substr(0, sizeof(config::SD_1_MOUNT_POINT)) ==
-             std::string(SdCardManager::SD_1_MOUNT_POINT)) {
+             std::string(config::SD_1_MOUNT_POINT)) {
-    if (!sdcMan->isSdCardMounted(sd::SLOT_0)) {
+    if (!sdcMan->isSdCardUsable(sd::SLOT_0)) {
       sif::warning << "StrHelper::checkPath: SD card 1 not mounted" << std::endl;
       return SD_NOT_MOUNTED;
     }

linux/devices/startracker/StrHelper.h

@@ -7,7 +7,7 @@
 #include "OBSWConfig.h"
 
 #ifdef XIPHOS_Q7S
-#include "bsp_q7s/memory/SdCardManager.h"
+#include "bsp_q7s/fs/SdCardManager.h"
 #endif
 
 #include "fsfw/devicehandlers/CookieIF.h"

linux/fsfwconfig/events/subsystemIdRanges.h

@@ -3,7 +3,7 @@
 
 #include <cstdint>
 
-#include "common/config/commonSubsystemIds.h"
+#include "eive/eventSubsystemIds.h"
 #include "fsfw/events/fwSubsystemIdRanges.h"
 
 /**

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 216 translations.
+ * @brief    Auto-generated event translation file. Contains 234 translations.
  * @details
- * Generated on: 2022-08-24 16:44:18
+ * Generated on: 2022-11-03 16:11:14
  */
 #include "translateEvents.h"
 
@@ -75,6 +75,7 @@ const char *OVERWRITING_HEALTH_STRING = "OVERWRITING_HEALTH";
 const char *TRYING_RECOVERY_STRING = "TRYING_RECOVERY";
 const char *RECOVERY_STEP_STRING = "RECOVERY_STEP";
 const char *RECOVERY_DONE_STRING = "RECOVERY_DONE";
+const char *HANDLE_PACKET_FAILED_STRING = "HANDLE_PACKET_FAILED";
 const char *RF_AVAILABLE_STRING = "RF_AVAILABLE";
 const char *RF_LOST_STRING = "RF_LOST";
 const char *BIT_LOCK_STRING = "BIT_LOCK";
@@ -85,6 +86,9 @@ const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
 const char *TC_DELETION_FAILED_STRING = "TC_DELETION_FAILED";
 const char *TEST_STRING = "TEST";
 const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
+const char *STORE_ERROR_STRING = "STORE_ERROR";
+const char *MSG_QUEUE_ERROR_STRING = "MSG_QUEUE_ERROR";
+const char *SERIALIZATION_ERROR_STRING = "SERIALIZATION_ERROR";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
@@ -97,11 +101,15 @@ const char *SWITCH_ALREADY_ON_STRING = "SWITCH_ALREADY_ON";
 const char *SWITCH_ALREADY_OFF_STRING = "SWITCH_ALREADY_OFF";
 const char *MAIN_SWITCH_TIMEOUT_STRING = "MAIN_SWITCH_TIMEOUT";
 const char *FAULTY_HEATER_WAS_ON_STRING = "FAULTY_HEATER_WAS_ON";
+const char *BURN_PHASE_START_STRING = "BURN_PHASE_START";
+const char *BURN_PHASE_DONE_STRING = "BURN_PHASE_DONE";
 const char *MAIN_SWITCH_ON_TIMEOUT_STRING = "MAIN_SWITCH_ON_TIMEOUT";
 const char *MAIN_SWITCH_OFF_TIMEOUT_STRING = "MAIN_SWITCH_OFF_TIMEOUT";
-const char *DEPLOYMENT_FAILED_STRING = "DEPLOYMENT_FAILED";
 const char *DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA1_GPIO_SWTICH_ON_FAILED";
 const char *DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_ON_FAILED";
+const char *DEPL_SA1_GPIO_SWTICH_OFF_FAILED_STRING = "DEPL_SA1_GPIO_SWTICH_OFF_FAILED";
+const char *DEPL_SA2_GPIO_SWTICH_OFF_FAILED_STRING = "DEPL_SA2_GPIO_SWTICH_OFF_FAILED";
+const char *AUTONOMOUS_DEPLOYMENT_COMPLETED_STRING = "AUTONOMOUS_DEPLOYMENT_COMPLETED";
 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";
@@ -136,6 +144,7 @@ const char *CARRIER_LOCK_STRING = "CARRIER_LOCK";
 const char *BIT_LOCK_PDEC_STRING = "BIT_LOCK_PDEC";
 const char *LOST_CARRIER_LOCK_PDEC_STRING = "LOST_CARRIER_LOCK_PDEC";
 const char *LOST_BIT_LOCK_PDEC_STRING = "LOST_BIT_LOCK_PDEC";
+const char *POLL_ERROR_PDEC_STRING = "POLL_ERROR_PDEC";
 const char *IMAGE_UPLOAD_FAILED_STRING = "IMAGE_UPLOAD_FAILED";
 const char *IMAGE_DOWNLOAD_FAILED_STRING = "IMAGE_DOWNLOAD_FAILED";
 const char *IMAGE_UPLOAD_SUCCESSFUL_STRING = "IMAGE_UPLOAD_SUCCESSFUL";
@@ -217,6 +226,15 @@ const char *ALLOC_FAILURE_STRING = "ALLOC_FAILURE";
 const char *REBOOT_SW_STRING = "REBOOT_SW";
 const char *REBOOT_MECHANISM_TRIGGERED_STRING = "REBOOT_MECHANISM_TRIGGERED";
 const char *REBOOT_HW_STRING = "REBOOT_HW";
+const char *NO_SD_CARD_ACTIVE_STRING = "NO_SD_CARD_ACTIVE";
+const char *MISSING_PACKET_STRING = "MISSING_PACKET";
+const char *EXPERIMENT_TIMEDOUT_STRING = "EXPERIMENT_TIMEDOUT";
+const char *MULTI_PACKET_COMMAND_DONE_STRING = "MULTI_PACKET_COMMAND_DONE";
+const char *SET_CONFIGFILEVALUE_FAILED_STRING = "SET_CONFIGFILEVALUE_FAILED";
+const char *GET_CONFIGFILEVALUE_FAILED_STRING = "GET_CONFIGFILEVALUE_FAILED";
+const char *INSERT_CONFIGFILEVALUE_FAILED_STRING = "INSERT_CONFIGFILEVALUE_FAILED";
+const char *WRITE_CONFIGFILE_FAILED_STRING = "WRITE_CONFIGFILE_FAILED";
+const char *READ_CONFIGFILE_FAILED_STRING = "READ_CONFIGFILE_FAILED";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -360,6 +378,8 @@ const char *translateEvents(Event event) {
       return RECOVERY_STEP_STRING;
     case (7512):
       return RECOVERY_DONE_STRING;
+    case (7600):
+      return HANDLE_PACKET_FAILED_STRING;
     case (7900):
       return RF_AVAILABLE_STRING;
     case (7901):
@@ -380,6 +400,12 @@ const char *translateEvents(Event event) {
       return TEST_STRING;
     case (10600):
       return CHANGE_OF_SETUP_PARAMETER_STRING;
+    case (10800):
+      return STORE_ERROR_STRING;
+    case (10801):
+      return MSG_QUEUE_ERROR_STRING;
+    case (10802):
+      return SERIALIZATION_ERROR_STRING;
     case (11300):
       return SWITCH_CMD_SENT_STRING;
     case (11301):
@@ -405,15 +431,23 @@ const char *translateEvents(Event event) {
     case (11407):
       return FAULTY_HEATER_WAS_ON_STRING;
     case (11500):
-      return MAIN_SWITCH_ON_TIMEOUT_STRING;
+      return BURN_PHASE_START_STRING;
     case (11501):
-      return MAIN_SWITCH_OFF_TIMEOUT_STRING;
+      return BURN_PHASE_DONE_STRING;
     case (11502):
-      return DEPLOYMENT_FAILED_STRING;
+      return MAIN_SWITCH_ON_TIMEOUT_STRING;
     case (11503):
-      return DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING;
+      return MAIN_SWITCH_OFF_TIMEOUT_STRING;
     case (11504):
+      return DEPL_SA1_GPIO_SWTICH_ON_FAILED_STRING;
+    case (11505):
       return DEPL_SA2_GPIO_SWTICH_ON_FAILED_STRING;
+    case (11506):
+      return DEPL_SA1_GPIO_SWTICH_OFF_FAILED_STRING;
+    case (11507):
+      return DEPL_SA2_GPIO_SWTICH_OFF_FAILED_STRING;
+    case (11508):
+      return AUTONOMOUS_DEPLOYMENT_COMPLETED_STRING;
     case (11601):
       return MEMORY_READ_RPT_CRC_FAILURE_STRING;
     case (11602):
@@ -482,6 +516,8 @@ const char *translateEvents(Event event) {
       return LOST_CARRIER_LOCK_PDEC_STRING;
     case (12406):
       return LOST_BIT_LOCK_PDEC_STRING;
+    case (12407):
+      return POLL_ERROR_PDEC_STRING;
     case (12500):
       return IMAGE_UPLOAD_FAILED_STRING;
     case (12501):
@@ -644,6 +680,24 @@ const char *translateEvents(Event event) {
       return REBOOT_MECHANISM_TRIGGERED_STRING;
     case (13703):
       return REBOOT_HW_STRING;
+    case (13704):
+      return NO_SD_CARD_ACTIVE_STRING;
+    case (13800):
+      return MISSING_PACKET_STRING;
+    case (13801):
+      return EXPERIMENT_TIMEDOUT_STRING;
+    case (13802):
+      return MULTI_PACKET_COMMAND_DONE_STRING;
+    case (13901):
+      return SET_CONFIGFILEVALUE_FAILED_STRING;
+    case (13902):
+      return GET_CONFIGFILEVALUE_FAILED_STRING;
+    case (13903):
+      return INSERT_CONFIGFILEVALUE_FAILED_STRING;
+    case (13904):
+      return WRITE_CONFIGFILE_FAILED_STRING;
+    case (13905):
+      return READ_CONFIGFILE_FAILED_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

linux/fsfwconfig/objects/systemObjectList.h

@@ -5,7 +5,7 @@
 
 #include <cstdint>
 
-#include "commonObjects.h"
+#include "eive/objects.h"
 
 // The objects will be instantiated in the ID order
 // For naming scheme see flight manual
@@ -40,7 +40,6 @@ enum sourceObjects : uint32_t {
   PUS_SERVICE_6 = 0x51000500,
 
   CCSDS_IP_CORE_BRIDGE = 0x73500000,
-  TM_FUNNEL = 0x73000100,
 
   /* 0x49 ('I') for Communication Interfaces **/
   ARDUINO_COM_IF = 0x49000000,
@@ -49,8 +48,10 @@ enum sourceObjects : uint32_t {
   UART_COM_IF = 0x49030003,
   SPI_MAIN_COM_IF = 0x49020004,
   GPIO_IF = 0x49010005,
+  SCEX_UART_READER = 0x49010006,
+
+  /* Custom device handler */
   SPI_RW_COM_IF = 0x49020005,
-  SPI_RTD_COM_IF = 0x49020006,
 
   /* 0x54 ('T') for test handlers */
   TEST_TASK = 0x54694269,