new fsfw

This reverts commit 2800484f6b.

CHANGELOG.md

@@ -10,6 +10,14 @@ list yields a list of all related PRs for each release.
 
 # [unreleased]
 
+# [v1.13.0]
+
+- Added first version of ACS Controller with gathers MGM data in a set
+
+# [v1.12.1] 05.07.2022
+
+- Disable periodic TCS controller HK generation by default
+
 # [v1.12.0] 04.07.2022
 
 ## Added

CMakeLists.txt

@@ -15,6 +15,7 @@ set(OBSW_VERSION_REVISION_IF_GIT_FAILS 0)
 
 # set(CMAKE_VERBOSE TRUE)
 
+
 option(
   EIVE_HARDCODED_TOOLCHAIN_FILE
   "\
@@ -160,7 +161,7 @@ if(NOT GIT_VER_HANDLING_OK)
 endif()
 
 # Set names and variables
-set(OBSW_NAME ${CMAKE_PROJECT_NAME})
+set(OBSW_NAME ${PROJECT_NAME})
 set(WATCHDOG_NAME eive-watchdog)
 set(SIMPLE_OBSW_NAME eive-simple)
 set(UNITTEST_NAME eive-unittest)
@@ -182,7 +183,7 @@ set(FSFW_PATH fsfw)
 set(TEST_PATH test)
 set(UNITTEST_PATH unittest)
 set(LINUX_PATH linux)
-set(COMMON_PATH common)
+set(COMMON_PATH ${CMAKE_CURRENT_SOURCE_DIR}/common)
 set(DUMMY_PATH dummies)
 set(WATCHDOG_PATH watchdog)
 set(COMMON_CONFIG_PATH ${COMMON_PATH}/config)
@@ -205,6 +206,7 @@ pre_source_hw_os_config()
 
 if(TGT_BSP)
   set(LIBGPS_VERSION_MAJOR 3)
+
   # I assume a newer version than 3.17 will be installed on other Linux board
   # than the Q7S
   set(LIBGPS_VERSION_MINOR 20)
@@ -214,11 +216,14 @@ if(TGT_BSP)
      OR TGT_BSP MATCHES "arm/egse"
      OR TGT_BSP MATCHES "arm/te0720-1cfa")
     find_library(${LIB_GPS} gps)
-    set(FSFW_CONFIG_PATH "linux/fsfwconfig")
+    set(FSFW_CONFIG_PATH ${CMAKE_CURRENT_SOURCE_DIR}/linux/fsfwconfig)
+
     if(NOT BUILD_Q7S_SIMPLE_MODE)
       set(EIVE_ADD_LINUX_FILES TRUE)
       set(ADD_CSP_LIB TRUE)
       set(FSFW_HAL_ADD_LINUX ON)
+      set(FSFW_HAL_LINUX_ADD_LIBGPIOD ON)
+      set(FSFW_HAL_LINUX_ADD_PERIPHERAL_DRIVERS ON)
     endif()
   endif()
 
@@ -269,8 +274,9 @@ endif()
 configure_file(${WATCHDOG_PATH}/watchdogConf.h.in watchdogConf.h)
 
 # Set common config path for FSFW
-set(FSFW_ADDITIONAL_INC_PATHS "${COMMON_PATH}/config"
-                              ${CMAKE_CURRENT_BINARY_DIR})
+set(FSFW_ADDITIONAL_INC_PATHS "${COMMON_PATH}"
+  ${COMMON_CONFIG_PATH}
+  ${CMAKE_CURRENT_BINARY_DIR})
 
 # ##############################################################################
 # Executable and Sources
@@ -318,7 +324,7 @@ add_library(${LIB_DUMMIES})
 
 # Add main executable
 add_executable(${OBSW_NAME})
-set(OBSW_BIN_NAME ${CMAKE_PROJECT_NAME})
+set(OBSW_BIN_NAME ${PROJECT_NAME})
 
 set_target_properties(${OBSW_NAME} PROPERTIES OUTPUT_NAME ${OBSW_BIN_NAME})
 
@@ -354,7 +360,10 @@ if(EIVE_ADD_LINUX_FILES)
   add_subdirectory(${LIB_ARCSEC_PATH})
   add_subdirectory(${LINUX_PATH})
 endif()
+
 add_subdirectory(${BSP_PATH})
+
+
 if(ADD_CSP_LIB)
   add_subdirectory(${LIB_CSP_PATH})
 endif()

bsp_q7s/CMakeLists.txt

@@ -9,7 +9,7 @@ add_subdirectory(simple)
 
 target_sources(${OBSW_NAME} PUBLIC main.cpp obsw.cpp)
 
-add_subdirectory(boardtest)
+#add_subdirectory(boardtest)
 
 add_subdirectory(boardconfig)
 add_subdirectory(comIF)

bsp_q7s/boardtest/CMakeLists.txt

@@ -1,4 +1,4 @@
-target_sources(${OBSW_NAME} PRIVATE FileSystemTest.cpp Q7STestTask.cpp)
+target_sources(${OBSW_NAME} PUBLIC FileSystemTest.cpp Q7STestTask.cpp)
 
 if(EIVE_BUILD_Q7S_SIMPLE_MODE)
   target_sources(${SIMPLE_OBSW_NAME} PRIVATE FileSystemTest.cpp)

bsp_q7s/callbacks/gnssCallback.cpp

@@ -4,11 +4,7 @@
 #include "fsfw/action/HasActionsIF.h"
 #include "fsfw/tasks/TaskFactory.h"
 
-ReturnValue_t gps::triggerGpioResetPin(const uint8_t* actionData, size_t len, void* args) {
-  // At least one byte which denotes which GPS to reset is required
-  if (len < 1 or actionData == nullptr) {
-    return HasActionsIF::INVALID_PARAMETERS;
-  }
+ReturnValue_t gps::triggerGpioResetPin(uint8_t gpsId, void* args) {
   ResetArgs* resetArgs = reinterpret_cast<ResetArgs*>(args);
   if (args == nullptr) {
     return HasReturnvaluesIF::RETURN_FAILED;
@@ -16,10 +12,8 @@ ReturnValue_t gps::triggerGpioResetPin(const uint8_t* actionData, size_t len, vo
   if (resetArgs->gpioComIF == nullptr) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
-  gpioId_t gpioId;
-  if (actionData[0] == 0) {
-    gpioId = gpioIds::GNSS_0_NRESET;
-  } else {
+  gpioId_t gpioId = gpioIds::GNSS_0_NRESET;
+  if (gpsId == 1) {
     gpioId = gpioIds::GNSS_1_NRESET;
   }
   resetArgs->gpioComIF->pullLow(gpioId);

bsp_q7s/callbacks/gnssCallback.h

@@ -11,7 +11,7 @@ struct ResetArgs {
 
 namespace gps {
 
-ReturnValue_t triggerGpioResetPin(const uint8_t* actionData, size_t len, void* args);
+ReturnValue_t triggerGpioResetPin(uint8_t gpsId, void* args);
 
 }
 

bsp_q7s/core/CoreActions.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <fsfw/action/MinMaxParameter.h>
+#include <fsfw/action/TemplateAction.h>
+#include <fsfw/introspection/Enum.h>
+
+class CoreController;
+
+namespace core {
+
+FSFW_ENUM(ActionId, ActionId_t,
+          ((LIST_DIRECTORY_INTO_FILE, 0, "List Directory into file"))(
+              (SWITCH_REBOOT_FILE_HANDLING, 5,
+               "Switch Reboot File Handling"))((RESET_REBOOT_COUNTERS, 6, "Reset Boot Counters"))(
+              (SWITCH_IMG_LOCK, 7, "Switch Image Lock"))((SET_MAX_REBOOT_CNT, 8,
+                                                          "Set maximum reboot Count"))(
+              (XSC_REBOOT_OBC, 32, "Reboot using the xsc_boot_copy command"))(
+              (MOUNT_OTHER_COPY, 33, "Mount Other Copy"))((REBOOT_OBC, 34,
+                                                           "Reboot using the reboot command")))
+
+FSFW_ENUM(Boolenum, uint8_t, ((NO, 0, "NO"))((YES, 1, "Yes")))
+
+class ListDirectoryIntoFileAction
+    : public TemplateAction<CoreController, ListDirectoryIntoFileAction, ActionId> {
+ public:
+  ListDirectoryIntoFileAction(CoreController *owner)
+      : TemplateAction(owner, ActionId::LIST_DIRECTORY_INTO_FILE){};
+};
+
+class SwitchRebootFileHandlingAction
+    : public TemplateAction<CoreController, SwitchRebootFileHandlingAction, ActionId> {
+ public:
+  SwitchRebootFileHandlingAction(CoreController *owner)
+      : TemplateAction(owner, ActionId::SWITCH_REBOOT_FILE_HANDLING){};
+
+  Parameter<Boolenum> enableRebootFile =
+      Parameter<Boolenum>::createParameter(this, "Enable Reboot File");
+};
+
+class ResetRebootCountersAction
+    : public TemplateAction<CoreController, ResetRebootCountersAction, ActionId> {
+ public:
+  FSFW_ENUM(Selection, uint8_t, ((ZERO, "0"))((ONE, "1"))((ALL, "All")))
+
+  ResetRebootCountersAction(CoreController *owner)
+      : TemplateAction(owner, ActionId::RESET_REBOOT_COUNTERS){};
+
+  Parameter<Selection> chip = Parameter<Selection>::createParameter(this, "Chip");
+  Parameter<Selection> copy = Parameter<Selection>::createParameter(this, "Copy");
+};
+
+class SwitchImageLockAction
+    : public TemplateAction<CoreController, SwitchImageLockAction, ActionId> {
+ public:
+  FSFW_ENUM(Selection, uint8_t, ((ZERO, "0"))((ONE, "1")))
+
+  SwitchImageLockAction(CoreController *owner) : TemplateAction(owner, ActionId::SWITCH_IMG_LOCK){};
+
+  Parameter<Boolenum> lock = Parameter<Boolenum>::createParameter(this, "Lock Image");
+  Parameter<Selection> chip = Parameter<Selection>::createParameter(this, "Chip");
+  Parameter<Selection> copy = Parameter<Selection>::createParameter(this, "Copy");
+};
+
+class SetMaxRebootCntAction
+    : public TemplateAction<CoreController, SetMaxRebootCntAction, ActionId> {
+ public:
+  SetMaxRebootCntAction(CoreController *owner)
+      : TemplateAction(owner, ActionId::SET_MAX_REBOOT_CNT){};
+
+    Parameter<uint8_t> maxCount = Parameter<uint8_t>::createParameter(this, "Count");
+};
+
+class XscRebootObcAction : public TemplateAction<CoreController, XscRebootObcAction, ActionId> {
+ public:
+  FSFW_ENUM(Selection, uint8_t, ((ZERO, "0"))((ONE, "1"))((SAME, "Same")))
+  XscRebootObcAction(CoreController *owner) : TemplateAction(owner, ActionId::XSC_REBOOT_OBC){};
+
+  Parameter<Selection> chip = Parameter<Selection>::createParameter(this, "Chip");
+  Parameter<Selection> copy = Parameter<Selection>::createParameter(this, "Copy");
+};
+
+class RebootObcAction : public TemplateAction<CoreController, RebootObcAction, ActionId> {
+ public:
+  RebootObcAction(CoreController *owner) : TemplateAction(owner, ActionId::REBOOT_OBC){};
+};
+
+}  // namespace core

bsp_q7s/core/CoreController.cpp

@@ -163,75 +163,73 @@ ReturnValue_t CoreController::initializeAfterTaskCreation() {
   return result;
 }
 
-ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                            const uint8_t *data, size_t size) {
-  switch (actionId) {
-    case (LIST_DIRECTORY_INTO_FILE): {
-      return actionListDirectoryIntoFile(actionId, commandedBy, data, size);
-    }
-    case (SWITCH_REBOOT_FILE_HANDLING): {
-      if (size < 1) {
-        return HasActionsIF::INVALID_PARAMETERS;
-      }
-      std::string path = sdcMan->getCurrentMountPrefix() + REBOOT_FILE;
-      // Disable the reboot file mechanism
-      parseRebootFile(path, rebootFile);
-      if (data[0] == 0) {
-        rebootFile.enabled = false;
-        rewriteRebootFile(rebootFile);
-      } else if (data[0] == 1) {
-        rebootFile.enabled = true;
-        rewriteRebootFile(rebootFile);
-      } else {
-        return HasActionsIF::INVALID_PARAMETERS;
-      }
-      return HasActionsIF::EXECUTION_FINISHED;
-    }
-    case (RESET_REBOOT_COUNTERS): {
-      if (size == 0) {
-        resetRebootCount(xsc::ALL_CHIP, xsc::ALL_COPY);
-      } else if (size == 2) {
-        if (data[0] > 1 or data[1] > 1) {
-          return HasActionsIF::INVALID_PARAMETERS;
-        }
-        resetRebootCount(static_cast<xsc::Chip>(data[0]), static_cast<xsc::Copy>(data[1]));
-      }
-      return HasActionsIF::EXECUTION_FINISHED;
-    }
-    case (SWITCH_IMG_LOCK): {
-      if (size != 3) {
-        return HasActionsIF::INVALID_PARAMETERS;
-      }
-      if (data[1] > 1 or data[2] > 1) {
-        return HasActionsIF::INVALID_PARAMETERS;
-      }
-      setRebootMechanismLock(data[0], static_cast<xsc::Chip>(data[1]),
-                             static_cast<xsc::Copy>(data[2]));
-      return HasActionsIF::EXECUTION_FINISHED;
-    }
-    case (SET_MAX_REBOOT_CNT): {
-      if (size < 1) {
-        return HasActionsIF::INVALID_PARAMETERS;
-      }
-      std::string path = sdcMan->getCurrentMountPrefix() + REBOOT_FILE;
-      // Disable the reboot file mechanism
-      parseRebootFile(path, rebootFile);
-      rebootFile.maxCount = data[0];
-      rewriteRebootFile(rebootFile);
-      return HasActionsIF::EXECUTION_FINISHED;
-    }
-    case (XSC_REBOOT_OBC): {
-      // Warning: This function will never return, because it reboots the system
-      return actionXscReboot(data, size);
-    }
-    case (REBOOT_OBC): {
-      // Warning: This function will never return, because it reboots the system
-      return actionReboot(data, size);
-    }
-    default: {
-      return HasActionsIF::INVALID_ACTION_ID;
-    }
+ReturnValue_t CoreController::executeAction(Action *action) { return action->handle(); }
+
+ReturnValue_t CoreController::handleAction(core::SwitchRebootFileHandlingAction *action) {
+  std::string path = sdcMan->getCurrentMountPrefix() + REBOOT_FILE;
+  // Disable the reboot file mechanism
+  parseRebootFile(path, rebootFile);
+  if (action->enableRebootFile.value == core::Boolenum::NO) {
+    rebootFile.enabled = false;
+    rewriteRebootFile(rebootFile);
+  } else {
+    rebootFile.enabled = true;
+    rewriteRebootFile(rebootFile);
   }
+  return HasActionsIF::EXECUTION_FINISHED;
+}
+
+ReturnValue_t CoreController::handleAction(core::ResetRebootCountersAction *action) {
+  xsc::Chip chip = xsc::NO_CHIP;
+  switch (action->chip.value) {
+    case core::ResetRebootCountersAction::Selection::ALL:
+      chip = xsc::ALL_CHIP;
+      break;
+    case core::ResetRebootCountersAction::Selection::ZERO:
+      chip = xsc::CHIP_0;
+      break;
+    case core::ResetRebootCountersAction::Selection::ONE:
+      chip = xsc::CHIP_1;
+      break;
+  }
+  xsc::Copy copy = xsc::NO_COPY;
+  switch (action->copy.value) {
+    case core::ResetRebootCountersAction::Selection::ALL:
+      copy = xsc::ALL_COPY;
+      break;
+    case core::ResetRebootCountersAction::Selection::ZERO:
+      copy = xsc::COPY_0;
+      break;
+    case core::ResetRebootCountersAction::Selection::ONE:
+      copy = xsc::COPY_1;
+      break;
+  }
+  resetRebootCount(chip, copy);
+
+  return HasActionsIF::EXECUTION_FINISHED;
+}
+
+ReturnValue_t CoreController::handleAction(core::SwitchImageLockAction *action) {
+  bool lock = action->lock.value == core::Boolenum::YES;
+  xsc::Chip chip = xsc::CHIP_0;
+  if (action->chip.value == core::SwitchImageLockAction::Selection::ONE) {
+    chip = xsc::CHIP_1;
+  }
+  xsc::Copy copy = xsc::COPY_0;
+  if (action->copy.value == core::SwitchImageLockAction::Selection::ONE) {
+    copy = xsc::COPY_0;
+  }
+  setRebootMechanismLock(lock, chip, copy);
+  return HasActionsIF::EXECUTION_FINISHED;
+}
+
+ReturnValue_t CoreController::handleAction(core::SetMaxRebootCntAction *action) {
+  std::string path = sdcMan->getCurrentMountPrefix() + REBOOT_FILE;
+  // Disable the reboot file mechanism
+  parseRebootFile(path, rebootFile);
+  rebootFile.maxCount = action->maxCount;
+  rewriteRebootFile(rebootFile);
+  return HasActionsIF::EXECUTION_FINISHED;
 }
 
 ReturnValue_t CoreController::checkModeCommand(Mode_t mode, Submode_t submode,
@@ -748,30 +746,29 @@ ReturnValue_t CoreController::initVersionFile() {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t CoreController::actionListDirectoryIntoFile(ActionId_t actionId,
-                                                          MessageQueueId_t commandedBy,
-                                                          const uint8_t *data, size_t size) {
+ReturnValue_t CoreController::handleAction(core::ListDirectoryIntoFileAction *action) {
   // TODO: Packet definition for clean deserialization
   // 2 bytes for a and R flag, at least 5 bytes for minimum valid path /tmp with
   // null termination, at least 7 bytes for minimum target file name /tmp/a with
   // null termination.
-  if (size < 14) {
-    return HasActionsIF::INVALID_PARAMETERS;
-  }
+  // TODO make work again
+  // if (size < 14) {
+  //   return HasActionsIF::INVALID_PARAMETERS;
+  // }
   // We could also make -l optional, but I can't think of a reason why to not use -l..
 
   // This flag specifies to run ls with -a
-  bool aFlag = data[0];
-  data += 1;
-  // This flag specifies to run ls with -R
-  bool RFlag = data[1];
-  data += 1;
+  bool aFlag = 0;  // data[0];
+  // data += 1;
+  //  This flag specifies to run ls with -R
+  bool RFlag = 0;  // data[1];
+  // data += 1;
 
-  size_t remainingSize = size - 2;
+  size_t remainingSize = 0;  // size - 2;
   // One larger for null termination, which prevents undefined behaviour if the sent
   // strings are not 0 terminated properly
   std::vector<uint8_t> repoAndTargetFileBuffer(remainingSize + 1, 0);
-  std::memcpy(repoAndTargetFileBuffer.data(), data, remainingSize);
+  // std::memcpy(repoAndTargetFileBuffer.data(), data, remainingSize);
   const char *currentCharPtr = reinterpret_cast<const char *>(repoAndTargetFileBuffer.data());
   // Full target file name
   std::string repoName(currentCharPtr);
@@ -798,7 +795,7 @@ ReturnValue_t CoreController::actionListDirectoryIntoFile(ActionId_t actionId,
   int result = std::system(oss.str().c_str());
   if (result != 0) {
     utility::handleSystemError(result, "CoreController::actionListDirectoryIntoFile");
-    actionHelper.finish(false, commandedBy, actionId);
+    actionHelper.finish(false, action->commandedBy, action->getId());
   }
   return HasReturnvaluesIF::RETURN_OK;
 }
@@ -857,11 +854,16 @@ void CoreController::initPrint() {
 #endif
 }
 
-ReturnValue_t CoreController::actionXscReboot(const uint8_t *data, size_t size) {
-  if (size < 1) {
+ReturnValue_t CoreController::handleAction(core::XscRebootObcAction *action) {
+  if (action->chip.value == core::XscRebootObcAction::Selection::SAME and
+      not(action->copy.value == core::XscRebootObcAction::Selection::SAME)) {
     return HasActionsIF::INVALID_PARAMETERS;
   }
-  bool rebootSameBootCopy = data[0];
+  bool rebootSameBootCopy = false;
+  if (action->chip.value == core::XscRebootObcAction::Selection::SAME and
+      action->copy.value == core::XscRebootObcAction::Selection::SAME) {
+    rebootSameBootCopy = true;
+  }
   bool protOpPerformed = false;
   SdCardManager::instance()->setBlocking(true);
   if (rebootSameBootCopy) {
@@ -876,19 +878,23 @@ ReturnValue_t CoreController::actionXscReboot(const uint8_t *data, size_t size)
     }
     return HasActionsIF::EXECUTION_FINISHED;
   }
-  if (size < 3 or (data[1] > 1 or data[2] > 1)) {
-    return HasActionsIF::INVALID_PARAMETERS;
-  }
 #if OBSW_VERBOSE_LEVEL >= 1
-  sif::info << "CoreController::actionPerformReboot: Rebooting on " << static_cast<int>(data[1])
-            << " " << static_cast<int>(data[2]) << std::endl;
+  sif::info << "CoreController::actionPerformReboot: Rebooting on "
+            << static_cast<uint8_t>(action->chip.value) << " "
+            << static_cast<uint8_t>(action->copy.value) << std::endl;
 #endif
 
   // Check that the target chip and copy is writeprotected first
   generateChipStateFile();
   // If any boot copies are unprotected, protect them here
-  auto tgtChip = static_cast<xsc::Chip>(data[1]);
-  auto tgtCopy = static_cast<xsc::Copy>(data[2]);
+  auto tgtChip = xsc::CHIP_0;
+  if (action->chip.value == core::XscRebootObcAction::Selection::ONE) {
+    tgtChip = xsc::CHIP_1;
+  }
+  auto tgtCopy = xsc::COPY_0;
+  if (action->copy.value == core::XscRebootObcAction::Selection::ONE) {
+    tgtCopy = xsc::COPY_1;
+  }
 
   // This function can not really fail
   gracefulShutdownTasks(tgtChip, tgtCopy, protOpPerformed);
@@ -932,7 +938,7 @@ ReturnValue_t CoreController::actionXscReboot(const uint8_t *data, size_t size)
   return HasReturnvaluesIF::RETURN_FAILED;
 }
 
-ReturnValue_t CoreController::actionReboot(const uint8_t *data, size_t size) {
+ReturnValue_t CoreController::handleAction(core::RebootObcAction *action) {
   bool protOpPerformed = false;
   gracefulShutdownTasks(xsc::Chip::CHIP_0, xsc::Copy::COPY_0, protOpPerformed);
   std::system("reboot");
@@ -1692,24 +1698,20 @@ void CoreController::resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy) {
   std::string path = currMntPrefix + REBOOT_FILE;
   // Disable the reboot file mechanism
   parseRebootFile(path, rebootFile);
-  if (tgtChip == xsc::ALL_CHIP and tgtCopy == xsc::ALL_COPY) {
-    rebootFile.img00Cnt = 0;
-    rebootFile.img01Cnt = 0;
-    rebootFile.img10Cnt = 0;
-    rebootFile.img11Cnt = 0;
-  } else {
-    if (tgtChip == xsc::CHIP_0) {
-      if (tgtCopy == xsc::COPY_0) {
-        rebootFile.img00Cnt = 0;
-      } else {
-        rebootFile.img01Cnt = 0;
-      }
-    } else {
-      if (tgtCopy == xsc::COPY_0) {
-        rebootFile.img10Cnt = 0;
-      } else {
-        rebootFile.img11Cnt = 0;
-      }
+  if (tgtChip == xsc::ALL_CHIP or tgtChip == xsc::CHIP_0) {
+    if (tgtCopy == xsc::ALL_COPY or tgtCopy == xsc::COPY_0) {
+      rebootFile.img00Cnt = 0;
+    }
+    if (tgtCopy == xsc::ALL_COPY or tgtCopy == xsc::COPY_1) {
+      rebootFile.img01Cnt = 0;
+    }
+  }
+  if (tgtChip == xsc::ALL_CHIP or tgtChip == xsc::CHIP_1) {
+    if (tgtCopy == xsc::ALL_COPY or tgtCopy == xsc::COPY_0) {
+      rebootFile.img10Cnt = 0;
+    }
+    if (tgtCopy == xsc::ALL_COPY or tgtCopy == xsc::COPY_1) {
+      rebootFile.img11Cnt = 0;
     }
   }
   rewriteRebootFile(rebootFile);
@@ -1849,3 +1851,7 @@ 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();
 }
+
+ModeDefinitionHelper CoreController::getModeDefinitionHelper() {
+  return ModeDefinitionHelper::create<ControllerModes, DefaultSubmode>();
+}

bsp_q7s/core/CoreController.h

@@ -6,6 +6,7 @@
 
 #include <cstddef>
 
+#include "CoreActions.h"
 #include "CoreDefinitions.h"
 #include "bsp_q7s/memory/SdCardManager.h"
 #include "events/subsystemIdRanges.h"
@@ -61,18 +62,6 @@ class CoreController : public ExtendedControllerBase {
       "/" + 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 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;
-
-  //! Reboot using the xsc_boot_copy command
-  static constexpr ActionId_t XSC_REBOOT_OBC = 32;
-  static constexpr ActionId_t MOUNT_OTHER_COPY = 33;
-  //! Reboot using the reboot command
-  static constexpr ActionId_t REBOOT_OBC = 34;
-
   static constexpr uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::CORE;
 
   static constexpr Event ALLOC_FAILURE = event::makeEvent(SUBSYSTEM_ID, 0, severity::MEDIUM);
@@ -94,8 +83,17 @@ class CoreController : public ExtendedControllerBase {
 
   ReturnValue_t initializeAfterTaskCreation() override;
 
-  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                              const uint8_t* data, size_t size) override;
+  ReturnValue_t executeAction(Action* action) override;
+
+  ReturnValue_t handleAction(core::ListDirectoryIntoFileAction* action);
+  ReturnValue_t handleAction(core::SwitchRebootFileHandlingAction* action);
+  ReturnValue_t handleAction(core::ResetRebootCountersAction* action);
+  ReturnValue_t handleAction(core::SwitchImageLockAction* action);
+  ReturnValue_t handleAction(core::SetMaxRebootCntAction* action);
+  ReturnValue_t handleAction(core::XscRebootObcAction* action);
+  ReturnValue_t handleAction(core::RebootObcAction* action);
+
+  ModeDefinitionHelper getModeDefinitionHelper() override;
 
   ReturnValue_t handleCommandMessage(CommandMessage* message) override;
   void performControlOperation() override;
@@ -197,6 +195,16 @@ class CoreController : public ExtendedControllerBase {
 
   core::HkSet hkSet;
 
+  core::ListDirectoryIntoFileAction listDirectoryIntoFileAction =
+      core::ListDirectoryIntoFileAction(this);
+  core::SwitchRebootFileHandlingAction switchRebootFileHandlingAction =
+      core::SwitchRebootFileHandlingAction(this);
+  core::ResetRebootCountersAction resetRebootCountersAction = core::ResetRebootCountersAction(this);
+  core::SwitchImageLockAction switchImageLockAction = core::SwitchImageLockAction(this);
+  core::SetMaxRebootCntAction setMaxRebootCntAction = core::SetMaxRebootCntAction(this);
+  core::XscRebootObcAction xscRebootObcAction = core::XscRebootObcAction(this);
+  core::RebootObcAction rebootObcAction = core::RebootObcAction(this);
+
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override;
   Countdown sdCardCheckCd = Countdown(120000);
@@ -224,8 +232,6 @@ class CoreController : public ExtendedControllerBase {
   void checkExternalSdCommandStatus();
   void performRebootFileHandling(bool recreateFile);
 
-  ReturnValue_t actionListDirectoryIntoFile(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                            const uint8_t* data, size_t size);
   ReturnValue_t actionXscReboot(const uint8_t* data, size_t size);
   ReturnValue_t actionReboot(const uint8_t* data, size_t size);
 

bsp_q7s/core/InitMission.cpp

@@ -133,6 +133,11 @@ void initmission::initTasks() {
   }
 #endif /* OBSW_ADD_ACS_HANDLERS */
 
+  acsTask->addComponent(objects::ACS_CONTROLLER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("ACS_CTRL", objects::ACS_CONTROLLER);
+  }
+
   PeriodicTaskIF* sysTask = factory->createPeriodicTask(
       "SYS_TASK", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
   static_cast<void>(sysTask);

bsp_q7s/core/ObjectFactory.cpp

@@ -478,10 +478,6 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
                                      acsBoardHelper, gpioComIF);
   static_cast<void>(acsAss);
 #endif /* OBSW_ADD_ACS_HANDLERS == 1 */
-
-#if OBSW_USE_CCSDS_IP_CORE == 1
-  createCcsdsComponents(gpioComIF);
-#endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
 }
 
 void ObjectFactory::createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher,

bsp_q7s/fmObjectFactory.cpp

@@ -63,4 +63,5 @@ void ObjectFactory::produce(void* args) {
 
   createMiscComponents();
   createThermalController();
+  createAcsController();
 }

bsp_q7s/memory/scratchApi.h

@@ -92,7 +92,7 @@ ReturnValue_t readToFile(std::string name, std::ifstream& file, std::string& fil
 
 }  // End of anonymous namespace
 
-template <typename T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+template <typename T, class>
 inline ReturnValue_t writeNumber(std::string key, T num) noexcept {
   std::ostringstream oss;
   oss << "xsc_scratch write " << key << " " << std::to_string(num);
@@ -104,7 +104,7 @@ inline ReturnValue_t writeNumber(std::string key, T num) noexcept {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-template <typename T, class = typename std::enable_if<std::is_integral<T>::value>::type>
+template <typename T, class>
 inline ReturnValue_t readNumber(std::string key, T& num) noexcept {
   using namespace std;
   ifstream file;

common/config/OBSWVersion.h

@@ -5,6 +5,6 @@ const char* const SW_NAME = "eive";
 
 #define SW_VERSION 1
 #define SW_SUBVERSION 12
-#define SW_REVISION 0
+#define SW_REVISION 1
 
 #endif /* COMMON_CONFIG_OBSWVERSION_H_ */

common/config/commonObjects.h

@@ -3,83 +3,85 @@
 
 #include <cstdint>
 
+#include <fsfw/introspection/ClasslessEnum.h>
+
 namespace objects {
-enum commonObjects : uint32_t {
+FSFW_CLASSLESS_ENUM(commonObjects, uint32_t,
   /* First Byte 0x50-0x52 reserved for PUS Services **/
-  CCSDS_PACKET_DISTRIBUTOR = 0x50000100,
-  PUS_PACKET_DISTRIBUTOR = 0x50000200,
-  TMTC_BRIDGE = 0x50000300,
-  TMTC_POLLING_TASK = 0x50000400,
-  FILE_SYSTEM_HANDLER = 0x50000500,
-  SDC_MANAGER = 0x50000550,
-  PTME = 0x50000600,
-  PDEC_HANDLER = 0x50000700,
-  CCSDS_HANDLER = 0x50000800,
+((CCSDS_PACKET_DISTRIBUTOR, 0x50000100, "CCSDS_PACKET_DISTRIBUTOR"))
+((PUS_PACKET_DISTRIBUTOR, 0x50000200, "PUS_PACKET_DISTRIBUTOR"))
+((TMTC_BRIDGE, 0x50000300, "TMTC_BRIDGE"))
+((TMTC_POLLING_TASK, 0x50000400, "TMTC_POLLING_TASK"))
+((FILE_SYSTEM_HANDLER, 0x50000500, "FILE_SYSTEM_HANDLER"))
+((SDC_MANAGER, 0x50000550, "SDC_MANAGER"))
+((PTME, 0x50000600, "PTME"))
+((PDEC_HANDLER, 0x50000700, "PDEC_HANDLER"))
+((CCSDS_HANDLER, 0x50000800, "CCSDS_HANDLER"))
 
   /* 0x43 ('C') for Controllers */
-  THERMAL_CONTROLLER = 0x43400001,
-  ACS_CONTROLLER = 0x43100002,
-  CORE_CONTROLLER = 0x43000003,
+((THERMAL_CONTROLLER, 0x43400001, "THERMAL_CONTROLLER"))
+((ACS_CONTROLLER, 0x43000002, "ACS_CONTROLLER"))
+((CORE_CONTROLLER, 0x43000003, "CORE_CONTROLLER"))
 
   /* 0x44 ('D') for device handlers */
-  MGM_0_LIS3_HANDLER = 0x44120006,
-  MGM_1_RM3100_HANDLER = 0x44120107,
-  MGM_2_LIS3_HANDLER = 0x44120208,
-  MGM_3_RM3100_HANDLER = 0x44120309,
-  GYRO_0_ADIS_HANDLER = 0x44120010,
-  GYRO_1_L3G_HANDLER = 0x44120111,
-  GYRO_2_ADIS_HANDLER = 0x44120212,
-  GYRO_3_L3G_HANDLER = 0x44120313,
-  RW1 = 0x44120047,
-  RW2 = 0x44120148,
-  RW3 = 0x44120249,
-  RW4 = 0x44120350,
-  STAR_TRACKER = 0x44130001,
-  GPS_CONTROLLER = 0x44130045,
+((MGM_0_LIS3_HANDLER, 0x44120006, "MGM_0_LIS3_HANDLER"))
+((MGM_1_RM3100_HANDLER, 0x44120107, "MGM_1_RM3100_HANDLER"))
+((MGM_2_LIS3_HANDLER, 0x44120208, "MGM_2_LIS3_HANDLER"))
+((MGM_3_RM3100_HANDLER, 0x44120309, "MGM_3_RM3100_HANDLER"))
+((GYRO_0_ADIS_HANDLER, 0x44120010, "GYRO_0_ADIS_HANDLER"))
+((GYRO_1_L3G_HANDLER, 0x44120111, "GYRO_1_L3G_HANDLER"))
+((GYRO_2_ADIS_HANDLER, 0x44120212, "GYRO_2_ADIS_HANDLER"))
+((GYRO_3_L3G_HANDLER, 0x44120313, "GYRO_3_L3G_HANDLER"))
+((RW1, 0x44120047, "RW1"))
+((RW2, 0x44120148, "RW2"))
+((RW3, 0x44120249, "RW3"))
+((RW4, 0x44120350, "RW4"))
+((STAR_TRACKER, 0x44130001, "STAR_TRACKER"))
+((GPS_CONTROLLER, 0x44130045, "GPS_CONTROLLER"))
 
-  IMTQ_HANDLER = 0x44140014,
-  TMP1075_HANDLER_1 = 0x44420004,
-  TMP1075_HANDLER_2 = 0x44420005,
-  PCDU_HANDLER = 0x442000A1,
-  P60DOCK_HANDLER = 0x44250000,
-  PDU1_HANDLER = 0x44250001,
-  PDU2_HANDLER = 0x44250002,
-  ACU_HANDLER = 0x44250003,
-  BPX_BATT_HANDLER = 0x44260000,
-  PLPCDU_HANDLER = 0x44300000,
-  RAD_SENSOR = 0x443200A5,
-  PLOC_UPDATER = 0x44330000,
-  PLOC_MEMORY_DUMPER = 0x44330001,
-  STR_HELPER = 0x44330002,
-  PLOC_MPSOC_HELPER = 0x44330003,
-  AXI_PTME_CONFIG = 0x44330004,
-  PTME_CONFIG = 0x44330005,
-  PLOC_MPSOC_HANDLER = 0x44330015,
-  PLOC_SUPERVISOR_HANDLER = 0x44330016,
-  PLOC_SUPERVISOR_HELPER = 0x44330017,
-  SOLAR_ARRAY_DEPL_HANDLER = 0x444100A2,
-  HEATER_HANDLER = 0x444100A4,
+((IMTQ_HANDLER, 0x44140014, "IMTQ_HANDLER"))
+((TMP1075_HANDLER_1, 0x44420004, "TMP1075_HANDLER_1"))
+((TMP1075_HANDLER_2, 0x44420005, "TMP1075_HANDLER_2"))
+((PCDU_HANDLER, 0x442000A1, "PCDU_HANDLER"))
+((P60DOCK_HANDLER, 0x44250000, "P60DOCK_HANDLER"))
+((PDU1_HANDLER, 0x44250001, "PDU1_HANDLER"))
+((PDU2_HANDLER, 0x44250002, "PDU2_HANDLER"))
+((ACU_HANDLER, 0x44250003, "ACU_HANDLER"))
+((BPX_BATT_HANDLER, 0x44260000, "BPX_BATT_HANDLER"))
+((PLPCDU_HANDLER, 0x44300000, "PLPCDU_HANDLER"))
+((RAD_SENSOR, 0x443200A5, "RAD_SENSOR"))
+((PLOC_UPDATER, 0x44330000, "PLOC_UPDATER"))
+((PLOC_MEMORY_DUMPER, 0x44330001, "PLOC_MEMORY_DUMPER"))
+((STR_HELPER, 0x44330002, "STR_HELPER"))
+((PLOC_MPSOC_HELPER, 0x44330003, "PLOC_MPSOC_HELPER"))
+((AXI_PTME_CONFIG, 0x44330004, "AXI_PTME_CONFIG"))
+((PTME_CONFIG, 0x44330005, "PTME_CONFIG"))
+((PLOC_MPSOC_HANDLER, 0x44330015, "PLOC_MPSOC_HANDLER"))
+((PLOC_SUPERVISOR_HANDLER, 0x44330016, "PLOC_SUPERVISOR_HANDLER"))
+((PLOC_SUPERVISOR_HELPER, 0x44330017, "PLOC_SUPERVISOR_HELPER"))
+((SOLAR_ARRAY_DEPL_HANDLER, 0x444100A2, "SOLAR_ARRAY_DEPL_HANDLER"))
+((HEATER_HANDLER, 0x444100A4, "HEATER_HANDLER"))
 
   /**
    * Not yet specified which pt1000 will measure which device/location in the satellite.
    * Therefore object ids are named according to the IC naming of the RTDs in the schematic.
    */
-  RTD_0_IC3_PLOC_HEATSPREADER = 0x44420016,
-  RTD_1_IC4_PLOC_MISSIONBOARD = 0x44420017,
-  RTD_2_IC5_4K_CAMERA = 0x44420018,
-  RTD_3_IC6_DAC_HEATSPREADER = 0x44420019,
-  RTD_4_IC7_STARTRACKER = 0x44420020,
-  RTD_5_IC8_RW1_MX_MY = 0x44420021,
-  RTD_6_IC9_DRO = 0x44420022,
-  RTD_7_IC10_SCEX = 0x44420023,
-  RTD_8_IC11_X8 = 0x44420024,
-  RTD_9_IC12_HPA = 0x44420025,
-  RTD_10_IC13_PL_TX = 0x44420026,
-  RTD_11_IC14_MPA = 0x44420027,
-  RTD_12_IC15_ACU = 0x44420028,
-  RTD_13_IC16_PLPCDU_HEATSPREADER = 0x44420029,
-  RTD_14_IC17_TCS_BOARD = 0x44420030,
-  RTD_15_IC18_IMTQ = 0x44420031,
+((RTD_0_IC3_PLOC_HEATSPREADER, 0x44420016, "RTD_0_IC3_PLOC_HEATSPREADER"))
+((RTD_1_IC4_PLOC_MISSIONBOARD, 0x44420017, "RTD_1_IC4_PLOC_MISSIONBOARD"))
+((RTD_2_IC5_4K_CAMERA, 0x44420018, "RTD_2_IC5_4K_CAMERA"))
+((RTD_3_IC6_DAC_HEATSPREADER, 0x44420019, "RTD_3_IC6_DAC_HEATSPREADER"))
+((RTD_4_IC7_STARTRACKER, 0x44420020, "RTD_4_IC7_STARTRACKER"))
+((RTD_5_IC8_RW1_MX_MY, 0x44420021, "RTD_5_IC8_RW1_MX_MY"))
+((RTD_6_IC9_DRO, 0x44420022, "RTD_6_IC9_DRO"))
+((RTD_7_IC10_SCEX, 0x44420023, "RTD_7_IC10_SCEX"))
+((RTD_8_IC11_X8, 0x44420024, "RTD_8_IC11_X8"))
+((RTD_9_IC12_HPA, 0x44420025, "RTD_9_IC12_HPA"))
+((RTD_10_IC13_PL_TX, 0x44420026, "RTD_10_IC13_PL_TX"))
+((RTD_11_IC14_MPA, 0x44420027, "RTD_11_IC14_MPA"))
+((RTD_12_IC15_ACU, 0x44420028, "RTD_12_IC15_ACU"))
+((RTD_13_IC16_PLPCDU_HEATSPREADER, 0x44420029, "RTD_13_IC16_PLPCDU_HEATSPREADER"))
+((RTD_14_IC17_TCS_BOARD, 0x44420030, "RTD_14_IC17_TCS_BOARD"))
+((RTD_15_IC18_IMTQ, 0x44420031, "RTD_15_IC18_IMTQ"))
 
   // Name convention for SUS devices
   // SUS_<IDX>_<N/R>_LOC_X<F/M/B>Y<F/M/B>Z<F/M/B>_PT_<DIR><F/B>
@@ -87,42 +89,42 @@ enum commonObjects : uint32_t {
   // PT: Pointing
   // N/R: Nominal/Redundant
   // F/M/B: Forward/Middle/Backwards
-  SUS_0_N_LOC_XFYFZM_PT_XF = 0x44120032,
-  SUS_6_R_LOC_XFYBZM_PT_XF = 0x44120038,
+((SUS_0_N_LOC_XFYFZM_PT_XF, 0x44120032, "SUS_0_N_LOC_XFYFZM_PT_XF"))
+((SUS_6_R_LOC_XFYBZM_PT_XF, 0x44120038, "SUS_6_R_LOC_XFYBZM_PT_XF"))
 
-  SUS_1_N_LOC_XBYFZM_PT_XB = 0x44120033,
-  SUS_7_R_LOC_XBYBZM_PT_XB = 0x44120039,
+((SUS_1_N_LOC_XBYFZM_PT_XB, 0x44120033, "SUS_1_N_LOC_XBYFZM_PT_XB"))
+((SUS_7_R_LOC_XBYBZM_PT_XB, 0x44120039, "SUS_7_R_LOC_XBYBZM_PT_XB"))
 
-  SUS_2_N_LOC_XFYBZB_PT_YB = 0x44120034,
-  SUS_8_R_LOC_XBYBZB_PT_YB = 0x44120040,
+((SUS_2_N_LOC_XFYBZB_PT_YB, 0x44120034, "SUS_2_N_LOC_XFYBZB_PT_YB"))
+((SUS_8_R_LOC_XBYBZB_PT_YB, 0x44120040, "SUS_8_R_LOC_XBYBZB_PT_YB"))
 
-  SUS_3_N_LOC_XFYBZF_PT_YF = 0x44120035,
-  SUS_9_R_LOC_XBYBZB_PT_YF = 0x44120041,
+((SUS_3_N_LOC_XFYBZF_PT_YF, 0x44120035, "SUS_3_N_LOC_XFYBZF_PT_YF"))
+((SUS_9_R_LOC_XBYBZB_PT_YF, 0x44120041, "SUS_9_R_LOC_XBYBZB_PT_YF"))
 
-  SUS_4_N_LOC_XMYFZF_PT_ZF = 0x44120036,
-  SUS_10_N_LOC_XMYBZF_PT_ZF = 0x44120042,
+((SUS_4_N_LOC_XMYFZF_PT_ZF, 0x44120036, "SUS_4_N_LOC_XMYFZF_PT_ZF"))
+((SUS_10_N_LOC_XMYBZF_PT_ZF, 0x44120042, "SUS_10_N_LOC_XMYBZF_PT_ZF"))
 
-  SUS_5_N_LOC_XFYMZB_PT_ZB = 0x44120037,
-  SUS_11_R_LOC_XBYMZB_PT_ZB = 0x44120043,
+((SUS_5_N_LOC_XFYMZB_PT_ZB, 0x44120037, "SUS_5_N_LOC_XFYMZB_PT_ZB"))
+((SUS_11_R_LOC_XBYMZB_PT_ZB, 0x44120043, "SUS_11_R_LOC_XBYMZB_PT_ZB"))
 
-  SYRLINKS_HK_HANDLER = 0x445300A3,
+((SYRLINKS_HK_HANDLER, 0x445300A3, "SYRLINKS_HK_HANDLER"))
 
   // 0x60 for other stuff
-  HEATER_0_PLOC_PROC_BRD = 0x60000000,
-  HEATER_1_PCDU_BRD = 0x60000001,
-  HEATER_2_ACS_BRD = 0x60000002,
-  HEATER_3_OBC_BRD = 0x60000003,
-  HEATER_4_CAMERA = 0x60000004,
-  HEATER_5_STR = 0x60000005,
-  HEATER_6_DRO = 0x60000006,
-  HEATER_7_HPA = 0x60000007,
+((HEATER_0_PLOC_PROC_BRD, 0x60000000, "HEATER_0_PLOC_PROC_BRD"))
+((HEATER_1_PCDU_BRD, 0x60000001, "HEATER_1_PCDU_BRD"))
+((HEATER_2_ACS_BRD, 0x60000002, "HEATER_2_ACS_BRD"))
+((HEATER_3_OBC_BRD, 0x60000003, "HEATER_3_OBC_BRD"))
+((HEATER_4_CAMERA, 0x60000004, "HEATER_4_CAMERA"))
+((HEATER_5_STR, 0x60000005, "HEATER_5_STR"))
+((HEATER_6_DRO, 0x60000006, "HEATER_6_DRO"))
+((HEATER_7_HPA, 0x60000007, "HEATER_7_HPA"))
 
   // 0x73 ('s') for assemblies and system/subsystem components
-  ACS_BOARD_ASS = 0x73000001,
-  SUS_BOARD_ASS = 0x73000002,
-  TCS_BOARD_ASS = 0x73000003,
-  RW_ASS = 0x73000004
-};
+((ACS_BOARD_ASS, 0x73000001, "ACS_BOARD_ASS"))
+((SUS_BOARD_ASS, 0x73000002, "SUS_BOARD_ASS"))
+((TCS_BOARD_ASS, 0x73000003, "TCS_BOARD_ASS"))
+((RW_ASS, 0x73000004, "RW_ASS"))
+)
 }
 
 #endif /* COMMON_CONFIG_COMMONOBJECTS_H_ */

generators/bsp_q7s_events.csv

@@ -78,7 +78,7 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 8901;0x22c5;CLOCK_SET_FAILURE;LOW;;fsfw/src/fsfw/pus/Service9TimeManagement.h
 9100;0x238c;TC_DELETION_FAILED;MEDIUM;Deletion of a TC from the map failed. P1: First 32 bit of request ID, P2. Last 32 bit of Request ID;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
 9700;0x25e4;TEST;INFO;;fsfw/src/fsfw/pus/Service17Test.h
-10600;0x2968;CHANGE_OF_SETUP_PARAMETER;LOW;;fsfw/hal/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
+10600;0x2968;CHANGE_OF_SETUP_PARAMETER;LOW;;fsfw/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.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

generators/bsp_q7s_returnvalues.csv

@@ -1,104 +1,55 @@
 Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x0000;OK;System-wide code for ok.;0;HasReturnvaluesIF;fsfw/returnvalues/HasReturnvaluesIF.h
 0x0001;Failed;Unspecified system-wide code for failed.;1;HasReturnvaluesIF;fsfw/returnvalues/HasReturnvaluesIF.h
-0x6100;GOMS_PacketTooLong;;0;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x6101;GOMS_InvalidTableId;;1;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x6102;GOMS_InvalidAddress;;2;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x6103;GOMS_InvalidParamSize;;3;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x6104;GOMS_InvalidPayloadSize;;4;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x6105;GOMS_UnknownReplyId;;5;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
-0x53a1;HEATER_CommandNotSupported;;161;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x53a2;HEATER_InitFailed;;162;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x53a3;HEATER_InvalidSwitchNr;;163;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x53a4;HEATER_MainSwitchSetTimeout;;164;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x53a5;HEATER_CommandAlreadyWaiting;;165;HEATER_HANDLER;mission/devices/HeaterHandler.h
-0x55a0;IMTQ_InvalidCommandCode;;160;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a1;IMTQ_ParameterMissing;;161;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a2;IMTQ_ParameterInvalid;;162;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a3;IMTQ_CcUnavailable;;163;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a4;IMTQ_InternalProcessingError;;164;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a5;IMTQ_RejectedWithoutReason;;165;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a6;IMTQ_CmdErrUnknown;;166;IMTQ_HANDLER;mission/devices/IMTQHandler.h
-0x55a7;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
-0x56b0;RWHA_SpiWriteFailure;;176;RW_HANDLER;mission/devices/RwHandler.h
-0x56b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/devices/RwHandler.h
-0x56b2;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
-0x56b3;RWHA_InvalidSubstitute;Can be used by the HDLC decoding mechanism to inform about an invalid substitution combination;179;RW_HANDLER;mission/devices/RwHandler.h
-0x56b4;RWHA_MissingEndSign;HDLC decoding mechanism never receives the end sign 0x7E;180;RW_HANDLER;mission/devices/RwHandler.h
-0x56b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/devices/RwHandler.h
-0x56b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/devices/RwHandler.h
-0x56a0;RWHA_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;RW_HANDLER;mission/devices/RwHandler.h
-0x56a1;RWHA_InvalidRampTime;Action Message with invalid ramp time was received.;161;RW_HANDLER;mission/devices/RwHandler.h
-0x56a2;RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;RW_HANDLER;mission/devices/RwHandler.h
-0x56a3;RWHA_ExecutionFailed;Command execution failed;163;RW_HANDLER;mission/devices/RwHandler.h
-0x56a4;RWHA_CrcError;Reaction wheel reply has invalid crc;164;RW_HANDLER;mission/devices/RwHandler.h
-0x6aa0;SADPL_CommandNotSupported;;160;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x6aa1;SADPL_DeploymentAlreadyExecuting;;161;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x6aa2;SADPL_MainSwitchTimeoutFailure;;162;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x6aa3;SADPL_SwitchingDeplSa1Failed;;163;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x6aa4;SADPL_SwitchingDeplSa2Failed;;164;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
-0x5ca0;SUSS_ErrorUnlockMutex;;160;SUS_HANDLER;mission/devices/SusHandler.h
-0x5ca1;SUSS_ErrorLockMutex;;161;SUS_HANDLER;mission/devices/SusHandler.h
-0x54a0;SYRLINKS_CrcFailure;;160;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a1;SYRLINKS_UartFraminOrParityErrorAck;;161;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a2;SYRLINKS_BadCharacterAck;;162;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a3;SYRLINKS_BadParameterValueAck;;163;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a4;SYRLINKS_BadEndOfFrameAck;;164;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a5;SYRLINKS_UnknownCommandIdAck;;165;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a6;SYRLINKS_BadCrcAck;;166;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a7;SYRLINKS_ReplyWrongSize;;167;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x54a8;SYRLINKS_MissingStartFrameCharacter;;168;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
-0x67a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NVMParameterBase.h
-0x64a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/tmtc/CCSDSHandler.h
-0x4701;HGIO_UnknownGpioId;;1;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4702;HGIO_DriveGpioFailure;;2;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4703;HGIO_GpioTypeFailure;;3;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4704;HGIO_GpioInvalidInstance;;4;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4705;HGIO_GpioDuplicateDetected;;5;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4706;HGIO_GpioInitFailed;;6;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4707;HGIO_GpioGetValueFailed;;7;HAL_GPIO;fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4400;HSPI_HalTimeoutRetval;;0;HAL_SPI;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x4401;HSPI_HalBusyRetval;;1;HAL_SPI;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x4402;HSPI_HalErrorRetval;;2;HAL_SPI;fsfw/hal/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x4501;HURT_UartReadFailure;;1;HAL_UART;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h
-0x4502;HURT_UartReadSizeMissmatch;;2;HAL_UART;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h
-0x4503;HURT_UartRxBufferTooSmall;;3;HAL_UART;fsfw/hal/src/fsfw_hal/linux/uart/UartComIF.h
-0x4300;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h
-0x4301;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/hal/src/fsfw_hal/linux/CommandExecutor.h
-0x4302;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h
-0x4303;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h
-0x4304;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h
-0x4306;UXOS_PcloseCallError;;6;LINUX_OSAL;fsfw/hal/src/fsfw_hal/linux/CommandExecutor.h
-0x3101;CF_ObjectHasNoFunctions;;1;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
-0x3102;CF_AlreadyCommanding;;2;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
-0x3201;HF_IsBusy;;1;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3202;HF_InvalidParameters;;2;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3203;HF_ExecutionFinished;;3;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3204;HF_InvalidActionId;;4;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
-0x3501;CFDP_InvalidTlvType;;1;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3502;CFDP_InvalidDirectiveFields;;2;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3503;CFDP_InvalidPduDatafieldLen;;3;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3504;CFDP_InvalidAckDirectiveFields;;4;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3505;CFDP_MetadataCantParseOptions;;5;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3506;CFDP_FinishedCantParseFsResponses;;6;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3508;CFDP_FilestoreRequiresSecondFile;;8;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3509;CFDP_FilestoreResponseCantParseFsMessage;;9;CFDP;fsfw/src/fsfw/cfdp/definitions.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
-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
-0x1601;FMM_MapFull;;1;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
-0x1602;FMM_KeyDoesNotExist;;2;FIXED_MULTIMAP;fsfw/src/fsfw/container/FixedOrderedMultimap.h
-0x37a1;SGP4_InvalidEccentricity;;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37a2;SGP4_InvalidMeanMotion;;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37a3;SGP4_InvalidPerturbationElements;;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37a4;SGP4_InvalidSemiLatusRectum;;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37a5;SGP4_InvalidEpochElements;;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37a6;SGP4_SatelliteHasDecayed;;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37b1;SGP4_TleTooOld;;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x37b2;SGP4_TleNotInitialized;;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x5fa0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/tmtc/CCSDSHandler.h
+0x5c00;GOMS_PacketTooLong;;0;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x5c01;GOMS_InvalidTableId;;1;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x5c02;GOMS_InvalidAddress;;2;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x5c03;GOMS_InvalidParamSize;;3;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x5c04;GOMS_InvalidPayloadSize;;4;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x5c05;GOMS_UnknownReplyId;;5;GOM_SPACE_HANDLER;mission/devices/GomspaceDeviceHandler.h
+0x51b0;RWHA_SpiWriteFailure;;176;RW_HANDLER;mission/devices/RwHandler.h
+0x51b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/devices/RwHandler.h
+0x51b2;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
+0x51b3;RWHA_InvalidSubstitute;Can be used by the HDLC decoding mechanism to inform about an invalid substitution combination;179;RW_HANDLER;mission/devices/RwHandler.h
+0x51b4;RWHA_MissingEndSign;HDLC decoding mechanism never receives the end sign 0x7E;180;RW_HANDLER;mission/devices/RwHandler.h
+0x51b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/devices/RwHandler.h
+0x51b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/devices/RwHandler.h
+0x51a0;RWHA_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;RW_HANDLER;mission/devices/RwHandler.h
+0x51a1;RWHA_InvalidRampTime;Action Message with invalid ramp time was received.;161;RW_HANDLER;mission/devices/RwHandler.h
+0x51a2;RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;RW_HANDLER;mission/devices/RwHandler.h
+0x51a3;RWHA_ExecutionFailed;Command execution failed;163;RW_HANDLER;mission/devices/RwHandler.h
+0x51a4;RWHA_CrcError;Reaction wheel reply has invalid crc;164;RW_HANDLER;mission/devices/RwHandler.h
+0x4ea1;HEATER_CommandNotSupported;;161;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x4ea2;HEATER_InitFailed;;162;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x4ea3;HEATER_InvalidSwitchNr;;163;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x4ea4;HEATER_MainSwitchSetTimeout;;164;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x4ea5;HEATER_CommandAlreadyWaiting;;165;HEATER_HANDLER;mission/devices/HeaterHandler.h
+0x57a0;SUSS_ErrorUnlockMutex;;160;SUS_HANDLER;mission/devices/SusHandler.h
+0x57a1;SUSS_ErrorLockMutex;;161;SUS_HANDLER;mission/devices/SusHandler.h
+0x50a0;IMTQ_InvalidCommandCode;;160;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x50a1;IMTQ_ParameterMissing;;161;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x50a2;IMTQ_ParameterInvalid;;162;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x50a3;IMTQ_CcUnavailable;;163;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x50a4;IMTQ_InternalProcessingError;;164;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x50a5;IMTQ_RejectedWithoutReason;;165;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x50a6;IMTQ_CmdErrUnknown;;166;IMTQ_HANDLER;mission/devices/IMTQHandler.h
+0x50a7;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
+0x4fa0;SYRLINKS_CrcFailure;;160;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
+0x4fa1;SYRLINKS_UartFraminOrParityErrorAck;;161;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
+0x4fa2;SYRLINKS_BadCharacterAck;;162;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
+0x4fa3;SYRLINKS_BadParameterValueAck;;163;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
+0x4fa4;SYRLINKS_BadEndOfFrameAck;;164;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
+0x4fa5;SYRLINKS_UnknownCommandIdAck;;165;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
+0x4fa6;SYRLINKS_BadCrcAck;;166;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
+0x4fa7;SYRLINKS_ReplyWrongSize;;167;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
+0x4fa8;SYRLINKS_MissingStartFrameCharacter;;168;SYRLINKS_HANDLER;mission/devices/SyrlinksHkHandler.h
+0x65a0;SADPL_CommandNotSupported;;160;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x65a1;SADPL_DeploymentAlreadyExecuting;;161;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x65a2;SADPL_MainSwitchTimeoutFailure;;162;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x65a3;SADPL_SwitchingDeplSa1Failed;;163;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x65a4;SADPL_SwitchingDeplSa2Failed;;164;SA_DEPL_HANDLER;mission/devices/SolarArrayDeploymentHandler.h
+0x62a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NVMParameterBase.h
 0x2b01;CCS_BcIsSetVrCommand;;1;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
 0x2b02;CCS_BcIsUnlockCommand;;2;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
 0x2bb0;CCS_BcIllegalCommand;;176;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
@@ -128,154 +79,7 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x2bd1;CCS_ShorterThanHeader;;209;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
 0x2bd2;CCS_TooShortBlockedPacket;;210;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
 0x2bd3;CCS_TooShortMapExtraction;;211;CCSDS_HANDLER_IF;fsfw/src/fsfw/datalinklayer/CCSDSReturnValuesIF.h
-0x0801;DPS_InvalidParameterDefinition;;1;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-0x0802;DPS_SetWasAlreadyRead;;2;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-0x0803;DPS_CommitingWithoutReading;;3;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
-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
-0x3ca0;PVA_InvalidReadWriteMode;;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
-0x3ca1;PVA_InvalidPoolEntry;;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
-0x3d00;HKM_QueueOrDestinationInvalid;;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d01;HKM_WrongHkPacketType;;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d02;HKM_ReportingStatusUnchanged;;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d03;HKM_PeriodicHelperInvalid;;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d04;HKM_PoolobjectNotFound;;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d05;HKM_DatasetNotFound;;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3b00;LPIF_PoolEntryNotFound;;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
-0x3b01;LPIF_PoolEntryTypeConflict;;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.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
-0x3301;DC_NoReplyReceived;;1;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3302;DC_ProtocolError;;2;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3303;DC_Nullpointer;;3;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3304;DC_InvalidCookieType;;4;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3305;DC_NotActive;;5;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3306;DC_TooMuchData;;6;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.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
-0x03b2;DHB_IgnoreFullPacket;;178;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
-0x03c0;DHB_NothingToSend;;192;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
-0x03c2;DHB_CommandMapError;;194;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
-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
-0x26a0;DHI_NoCommandData;;160;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a1;DHI_CommandNotSupported;;161;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a2;DHI_CommandAlreadySent;;162;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a3;DHI_CommandWasNotSent;;163;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a4;DHI_CantSwitchAddress;;164;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a5;DHI_WrongModeForCommand;;165;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a6;DHI_Timeout;;166;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a7;DHI_Busy;;167;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a8;DHI_NoReplyExpected;;168;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26a9;DHI_NonOpTemperature;;169;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26aa;DHI_CommandNotImplemented;;170;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26b0;DHI_ChecksumError;;176;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26b1;DHI_LengthMissmatch;;177;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26b2;DHI_InvalidData;;178;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26b3;DHI_ProtocolError;;179;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26c0;DHI_DeviceDidNotExecute;;192;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26c1;DHI_DeviceReportedError;;193;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26c2;DHI_UnknownDeviceReply;;194;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26c3;DHI_DeviceReplyInvalid;;195;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26d0;DHI_InvalidCommandParameter;;208;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x26d1;DHI_InvalidNumberOrLengthOfParameters;;209;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
-0x2401;EV_ListenerNotFound;;1;EVENT_MANAGER_IF;fsfw/src/fsfw/events/EventManagerIF.h
-0x2500;FDI_YourFault;;0;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x2501;FDI_MyFault;;1;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x2502;FDI_ConfirmLater;;2;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
-0x2301;MT_TooDetailedRequest;;1;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2302;MT_TooGeneralRequest;;2;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2303;MT_NoMatch;;3;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2304;MT_Full;;4;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2305;MT_NewNodeCreated;;5;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
-0x2e01;ASC_TooLongForTargetType;;1;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
-0x2e02;ASC_InvalidCharacters;;2;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
-0x2e03;ASC_BufferTooSmall;;3;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
-0x3e01;DLEE_StreamTooShort;;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x3e02;DLEE_DecodingError;;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.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
-0x0f01;CM_UnknownCommand;;1;COMMAND_MESSAGE;fsfw/src/fsfw/ipc/CommandMessageIF.h
-0x3901;MQI_Empty;;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3902;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3903;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3904;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3801;MUX_NotEnoughResources;;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3802;MUX_InsufficientMemory;;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3803;MUX_NoPrivilege;;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3804;MUX_WrongAttributeSetting;;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3805;MUX_MutexAlreadyLocked;;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3806;MUX_MutexNotFound;;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3807;MUX_MutexMaxLocks;;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3808;MUX_CurrThreadAlreadyOwnsMutex;;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3809;MUX_CurrThreadDoesNotOwnMutex;;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x380a;MUX_MutexTimeout;;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x380b;MUX_MutexInvalidId;;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x380c;MUX_MutexDestroyedWhileWaiting;;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x4200;FILS_GenericFileError;;0;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x4201;FILS_IsBusy;;1;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x4202;FILS_InvalidParameters;;2;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x4205;FILS_FileDoesNotExist;;5;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x4206;FILS_FileAlreadyExists;;6;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x4207;FILS_FileLocked;;7;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x420a;FILS_DirectoryDoesNotExist;;10;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x420b;FILS_DirectoryAlreadyExists;;11;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x420c;FILS_DirectoryNotEmpty;;12;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x420f;FILS_SequencePacketMissingWrite;;15;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x4210;FILS_SequencePacketMissingRead;;16;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
-0x0601;PP_DoItMyself;;1;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0602;PP_PointsToVariable;;2;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0603;PP_PointsToMemory;;3;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
-0x0604;PP_ActivityCompleted;;4;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.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
-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
-0x3001;LIM_Unchecked;;1;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3002;LIM_Invalid;;2;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3003;LIM_Unselected;;3;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3004;LIM_BelowLowLimit;;4;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3005;LIM_AboveHighLimit;;5;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3006;LIM_UnexpectedValue;;6;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x3007;LIM_OutOfRange;;7;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x30a0;LIM_FirstSample;;160;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x30e0;LIM_InvalidSize;;224;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x30e1;LIM_WrongType;;225;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x30e2;LIM_WrongPid;;226;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x30e3;LIM_WrongLimitId;;227;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
-0x30ee;LIM_MonitorNotFound;;238;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.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
-0x1a04;TRC_BothValuesOol;;4;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
-0x1a05;TRC_DuplexOol;;5;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.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
-0x0200;OM_ConnBroken;;0;OBJECT_MANAGER_IF;fsfw/src/fsfw/osal/common/TcpTmTcServer.h
+0x3a00;SPH_ConnBroken;;0;SEMAPHORE_IF;fsfw/src/fsfw/osal/common/TcpTmTcServer.h
 0x2901;IEC_NoConfigurationTable;;1;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
 0x2902;IEC_NoCpuTable;;2;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
 0x2903;IEC_InvalidWorkspaceAddress;;3;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
@@ -297,6 +101,10 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x2913;IEC_ImplementationBlockingOperationCancel;;19;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
 0x2914;IEC_MutexObtainFromBadState;;20;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.h
 0x2915;IEC_UnlimitedAndMaximumIs0;;21;INTERNAL_ERROR_CODES;fsfw/src/fsfw/osal/InternalErrorCodes.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
 0x2d01;HPA_InvalidIdentifierId;;1;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
 0x2d02;HPA_InvalidDomainId;;2;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
 0x2d03;HPA_InvalidValue;;3;HAS_PARAMETERS_IF;fsfw/src/fsfw/parameters/HasParametersIF.h
@@ -309,16 +117,53 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x2c06;PAW_OutOfBounds;;6;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
 0x2c07;PAW_NotSet;;7;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
 0x2c08;PAW_ColumnOrRowsZero;;8;PARAMETER_WRAPPER;fsfw/src/fsfw/parameters/ParameterWrapper.h
-0x2f01;POS_InPowerTransition;;1;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
-0x2f02;POS_SwitchStateMismatch;;2;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
-0x0501;PS_SwitchOn;;1;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
-0x0500;PS_SwitchOff;;0;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
-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
-0x4101;PUS11_InvalidTypeTimeWindow;;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4102;PUS11_TimeshiftingNotPossible;;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4103;PUS11_InvalidRelativeTime;;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x3101;CF_ObjectHasNoFunctions;;1;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
+0x3102;CF_AlreadyCommanding;;2;COMMANDS_ACTIONS_IF;fsfw/src/fsfw/action/CommandsActionsIF.h
+0x3201;HF_IsBusy;;1;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x3202;HF_InvalidParameters;;2;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x3203;HF_ExecutionFinished;;3;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.h
+0x3204;HF_InvalidActionId;;4;HAS_ACTIONS_IF;fsfw/src/fsfw/action/HasActionsIF.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
+0x2500;FDI_YourFault;;0;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
+0x2501;FDI_MyFault;;1;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
+0x2502;FDI_ConfirmLater;;2;HANDLES_FAILURES_IF;fsfw/src/fsfw/fdir/ConfirmsFailuresIF.h
+0x2101;TMF_Busy;;1;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2102;TMF_LastPacketFound;;2;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2103;TMF_StopFetch;;3;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2104;TMF_Timeout;;4;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2105;TMF_TmChannelFull;;5;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2106;TMF_NotStored;;6;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2107;TMF_AllDeleted;;7;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2108;TMF_InvalidData;;8;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2109;TMF_NotReady;;9;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
+0x2001;TMB_Busy;;1;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2002;TMB_Full;;2;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2003;TMB_Empty;;3;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2004;TMB_NullRequested;;4;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2005;TMB_TooLarge;;5;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2006;TMB_NotReady;;6;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2007;TMB_DumpError;;7;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2008;TMB_CrcError;;8;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x2009;TMB_Timeout;;9;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x200a;TMB_IdlePacketFound;;10;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x200b;TMB_TelecommandFound;;11;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x200c;TMB_NoPusATm;;12;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x200d;TMB_TooSmall;;13;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x200e;TMB_BlockNotFound;;14;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x200f;TMB_InvalidRequest;;15;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
+0x1c01;TCD_PacketLost;;1;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributor.h
+0x1c02;TCD_DestinationNotFound;;2;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributor.h
+0x1c03;TCD_ServiceIdAlreadyExists;;3;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributor.h
+0x1b00;TCC_IllegalApid;;0;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
+0x1b01;TCC_IncompletePacket;;1;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
+0x1b02;TCC_IncorrectChecksum;;2;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
+0x1b03;TCC_IllegalPacketType;;3;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
+0x1b04;TCC_IllegalPacketSubtype;;4;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
+0x1b05;TCC_IncorrectPrimaryHeader;;5;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
+0x1b06;TCC_IncorrectSecondaryHeader;;6;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.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
@@ -359,15 +204,61 @@ 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
-0x1402;SE_StreamTooShort;;2;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
-0x1403;SE_TooManyElements;;3;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
 0x2701;SM_DataTooLarge;;1;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
 0x2702;SM_DataStorageFull;;2;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
 0x2703;SM_IllegalStorageId;;3;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
 0x2704;SM_DataDoesNotExist;;4;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
 0x2705;SM_IllegalAddress;;5;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
 0x2706;SM_PoolTooLarge;;6;STORAGE_MANAGER_IF;fsfw/src/fsfw/storagemanager/StorageManagerIF.h
+0x37a1;SGP4_InvalidEccentricity;;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x37a2;SGP4_InvalidMeanMotion;;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x37a3;SGP4_InvalidPerturbationElements;;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x37a4;SGP4_InvalidSemiLatusRectum;;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x37a5;SGP4_InvalidEpochElements;;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x37a6;SGP4_SatelliteHasDecayed;;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x37b1;SGP4_TleTooOld;;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x37b2;SGP4_TleNotInitialized;;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x2301;MT_TooDetailedRequest;;1;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2302;MT_TooGeneralRequest;;2;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2303;MT_NoMatch;;3;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2304;MT_Full;;4;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x2305;MT_NewNodeCreated;;5;MATCH_TREE_CLASS;fsfw/src/fsfw/globalfunctions/matching/MatchTree.h
+0x3e01;DLEE_StreamTooShort;;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x3e02;DLEE_DecodingError;;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x2e01;ASC_TooLongForTargetType;;1;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x2e02;ASC_InvalidCharacters;;2;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x2e03;ASC_BufferTooSmall;;3;ASCII_CONVERTER;fsfw/src/fsfw/globalfunctions/AsciiConverter.h
+0x0f01;CM_UnknownCommand;;1;COMMAND_MESSAGE;fsfw/src/fsfw/ipc/CommandMessageIF.h
+0x3901;MQI_Empty;;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3902;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3903;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3904;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3801;MUX_NotEnoughResources;;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3802;MUX_InsufficientMemory;;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3803;MUX_NoPrivilege;;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3804;MUX_WrongAttributeSetting;;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3805;MUX_MutexAlreadyLocked;;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3806;MUX_MutexNotFound;;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3807;MUX_MutexMaxLocks;;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3808;MUX_CurrThreadAlreadyOwnsMutex;;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3809;MUX_CurrThreadDoesNotOwnMutex;;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x380a;MUX_MutexTimeout;;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x380b;MUX_MutexInvalidId;;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x380c;MUX_MutexDestroyedWhileWaiting;;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a01;SPH_SemaphoreTimeout;;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3a02;SPH_SemaphoreNotOwned;;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3a03;SPH_SemaphoreInvalid;;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3501;CFDP_InvalidTlvType;;1;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3502;CFDP_InvalidDirectiveFields;;2;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3503;CFDP_InvalidPduDatafieldLen;;3;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3504;CFDP_InvalidAckDirectiveFields;;4;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3505;CFDP_MetadataCantParseOptions;;5;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3506;CFDP_FinishedCantParseFsResponses;;6;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3508;CFDP_FilestoreRequiresSecondFile;;8;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x3509;CFDP_FilestoreResponseCantParseFsMessage;;9;CFDP;fsfw/src/fsfw/cfdp/definitions.h
+0x2801;TC_InvalidTargetState;;1;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
+0x28f1;TC_AboveOperationalLimit;;241;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
+0x28f2;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
@@ -390,22 +281,22 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 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
-0x3a01;SPH_SemaphoreTimeout;;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3a02;SPH_SemaphoreNotOwned;;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3a03;SPH_SemaphoreInvalid;;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x1c01;TCD_PacketLost;;1;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributor.h
-0x1c02;TCD_DestinationNotFound;;2;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributor.h
-0x1c03;TCD_ServiceIdAlreadyExists;;3;PACKET_DISTRIBUTION;fsfw/src/fsfw/tcdistribution/TcDistributor.h
-0x1b00;TCC_IllegalApid;;0;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x1b01;TCC_IncompletePacket;;1;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x1b02;TCC_IncorrectChecksum;;2;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x1b03;TCC_IllegalPacketType;;3;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x1b04;TCC_IllegalPacketSubtype;;4;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x1b05;TCC_IncorrectPrimaryHeader;;5;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x1b06;TCC_IncorrectSecondaryHeader;;6;TC_PACKET_CHECK;fsfw/src/fsfw/tcdistribution/TcPacketCheckPUS.h
-0x2801;TC_InvalidTargetState;;1;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
-0x28f1;TC_AboveOperationalLimit;;241;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
-0x28f2;TC_BelowOperationalLimit;;242;THERMAL_COMPONENT_IF;fsfw/src/fsfw/thermal/ThermalComponentIF.h
+0x3d00;HKM_QueueOrDestinationInvalid;;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3d01;HKM_WrongHkPacketType;;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3d02;HKM_ReportingStatusUnchanged;;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3d03;HKM_PeriodicHelperInvalid;;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3d04;HKM_PoolobjectNotFound;;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3d05;HKM_DatasetNotFound;;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x3b00;LPIF_PoolEntryNotFound;;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3b01;LPIF_PoolEntryTypeConflict;;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3ca0;PVA_InvalidReadWriteMode;;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
+0x3ca1;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
+0x0802;DPS_SetWasAlreadyRead;;2;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
+0x0803;DPS_CommitingWithoutReading;;3;DATA_SET_CLASS;fsfw/src/fsfw/datapool/DataSetIF.h
+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
 0x1000;TIM_UnsupportedTimeFormat;;0;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
 0x1001;TIM_NotEnoughInformationForTargetFormat;;1;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
 0x1002;TIM_LengthMismatch;;2;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
@@ -413,35 +304,13 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x1004;TIM_InvalidDayOfYear;;4;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
 0x1005;TIM_TimeDoesNotFitFormat;;5;CCSDS_TIME_HELPER_CLASS;fsfw/src/fsfw/timemanager/CCSDSTime.h
 0x3601;TSI_BadTimestamp;;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStamperIF.h
-0x2001;TMB_Busy;;1;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2002;TMB_Full;;2;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2003;TMB_Empty;;3;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2004;TMB_NullRequested;;4;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2005;TMB_TooLarge;;5;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2006;TMB_NotReady;;6;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2007;TMB_DumpError;;7;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2008;TMB_CrcError;;8;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2009;TMB_Timeout;;9;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x200a;TMB_IdlePacketFound;;10;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x200b;TMB_TelecommandFound;;11;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x200c;TMB_NoPusATm;;12;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x200d;TMB_TooSmall;;13;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x200e;TMB_BlockNotFound;;14;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x200f;TMB_InvalidRequest;;15;TM_STORE_BACKEND_IF;fsfw/src/fsfw/tmstorage/TmStoreBackendIF.h
-0x2101;TMF_Busy;;1;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2102;TMF_LastPacketFound;;2;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2103;TMF_StopFetch;;3;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2104;TMF_Timeout;;4;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2105;TMF_TmChannelFull;;5;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2106;TMF_NotStored;;6;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2107;TMF_AllDeleted;;7;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2108;TMF_InvalidData;;8;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
-0x2109;TMF_NotReady;;9;TM_STORE_FRONTEND_IF;fsfw/src/fsfw/tmstorage/TmStoreFrontendIF.h
 0x1d01;PUS_ActivityStarted;;1;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
 0x1d02;PUS_InvalidSubservice;;2;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
 0x1d03;PUS_IllegalApplicationData;;3;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
 0x1d04;PUS_SendTmFailed;;4;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
 0x1d05;PUS_Timeout;;5;ACCEPTS_TELECOMMANDS_IF;fsfw/src/fsfw/tmtcservices/AcceptsTelecommandsIF.h
+0x4b00;SPPA_NoPacketFound;;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x4b01;SPPA_SplitPacket;;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
 0x1f01;CSB_ExecutionComplete;;1;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
 0x1f02;CSB_NoStepMessage;;2;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
 0x1f03;CSB_ObjectBusy;;3;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
@@ -449,18 +318,149 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x1f05;CSB_InvalidTc;;5;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
 0x1f06;CSB_InvalidObject;;6;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
 0x1f07;CSB_InvalidReply;;7;COMMAND_SERVICE_BASE;fsfw/src/fsfw/tmtcservices/CommandingServiceBase.h
-0x4b00;SPPA_NoPacketFound;;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x4b01;SPPA_SplitPacket;;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x68a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;160;FILE_SYSTEM_HELPER;bsp_q7s/memory/FilesystemHelper.h
-0x68a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;161;FILE_SYSTEM_HELPER;bsp_q7s/memory/FilesystemHelper.h
-0x7400;SCBU_KeyNotFound;;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h
-0x7300;SDMA_OpOngoing;;0;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x7301;SDMA_AlreadyOn;;1;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x7302;SDMA_AlreadyMounted;;2;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x7303;SDMA_AlreadyOff;;3;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x730a;SDMA_StatusFileNexists;;10;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x730b;SDMA_StatusFileFormatInvalid;;11;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x730c;SDMA_MountError;;12;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x730d;SDMA_UnmountError;;13;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x730e;SDMA_SystemCallError;;14;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
-0x730f;SDMA_PopenCallError;;15;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.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
+0x2401;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
+0x2f01;POS_InPowerTransition;;1;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
+0x2f02;POS_SwitchStateMismatch;;2;POWER_SWITCHER;fsfw/src/fsfw/power/PowerSwitcher.h
+0x0501;PS_SwitchOn;;1;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
+0x0500;PS_SwitchOff;;0;POWER_SWITCH_IF;fsfw/src/fsfw/power/PowerSwitchIF.h
+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
+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
+0x1a04;TRC_BothValuesOol;;4;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
+0x1a05;TRC_DuplexOol;;5;TRIPLE_REDUNDACY_CHECK;fsfw/src/fsfw/monitoring/TriplexMonitor.h
+0x3001;LIM_Unchecked;;1;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3002;LIM_Invalid;;2;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3003;LIM_Unselected;;3;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3004;LIM_BelowLowLimit;;4;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3005;LIM_AboveHighLimit;;5;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3006;LIM_UnexpectedValue;;6;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x3007;LIM_OutOfRange;;7;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x30a0;LIM_FirstSample;;160;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x30e0;LIM_InvalidSize;;224;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x30e1;LIM_WrongType;;225;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x30e2;LIM_WrongPid;;226;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x30e3;LIM_WrongLimitId;;227;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x30ee;LIM_MonitorNotFound;;238;LIMITS_IF;fsfw/src/fsfw/monitoring/MonitoringIF.h
+0x4101;PUS11_InvalidTypeTimeWindow;;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4102;PUS11_TimeshiftingNotPossible;;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4103;PUS11_InvalidRelativeTime;;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4200;FILS_GenericFileError;;0;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x4201;FILS_IsBusy;;1;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x4202;FILS_InvalidParameters;;2;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x4205;FILS_FileDoesNotExist;;5;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x4206;FILS_FileAlreadyExists;;6;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x4207;FILS_FileLocked;;7;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x420a;FILS_DirectoryDoesNotExist;;10;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x420b;FILS_DirectoryAlreadyExists;;11;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x420c;FILS_DirectoryNotEmpty;;12;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x420f;FILS_SequencePacketMissingWrite;;15;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x4210;FILS_SequencePacketMissingRead;;16;FILE_SYSTEM;fsfw/src/fsfw/memory/HasFileSystemIF.h
+0x0601;PP_DoItMyself;;1;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0602;PP_PointsToVariable;;2;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0603;PP_PointsToMemory;;3;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.h
+0x0604;PP_ActivityCompleted;;4;HAS_MEMORY_IF;fsfw/src/fsfw/memory/HasMemoryIF.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
+0x03b2;DHB_IgnoreFullPacket;;178;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
+0x03c0;DHB_NothingToSend;;192;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
+0x03c2;DHB_CommandMapError;;194;DEVICE_HANDLER_BASE;fsfw/src/fsfw/devicehandlers/DeviceHandlerBase.h
+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
+0x3301;DC_NoReplyReceived;;1;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3302;DC_ProtocolError;;2;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3303;DC_Nullpointer;;3;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3304;DC_InvalidCookieType;;4;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3305;DC_NotActive;;5;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x3306;DC_TooMuchData;;6;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
+0x26a0;DHI_NoCommandData;;160;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26a1;DHI_CommandNotSupported;;161;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26a2;DHI_CommandAlreadySent;;162;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26a3;DHI_CommandWasNotSent;;163;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26a4;DHI_CantSwitchAddress;;164;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26a5;DHI_WrongModeForCommand;;165;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26a6;DHI_Timeout;;166;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26a7;DHI_Busy;;167;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26a8;DHI_NoReplyExpected;;168;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26a9;DHI_NonOpTemperature;;169;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26aa;DHI_CommandNotImplemented;;170;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26b0;DHI_ChecksumError;;176;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26b1;DHI_LengthMissmatch;;177;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26b2;DHI_InvalidData;;178;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26b3;DHI_ProtocolError;;179;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26c0;DHI_DeviceDidNotExecute;;192;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26c1;DHI_DeviceReportedError;;193;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26c2;DHI_UnknownDeviceReply;;194;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26c3;DHI_DeviceReplyInvalid;;195;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26d0;DHI_InvalidCommandParameter;;208;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x26d1;DHI_InvalidNumberOrLengthOfParameters;;209;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
+0x1401;SE_BufferTooShort;;1;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
+0x1402;SE_StreamTooShort;;2;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
+0x1403;SE_TooManyElements;;3;SERIALIZE_IF;fsfw/src/fsfw/serialize/SerializeIF.h
+0x4400;HSPI_HalTimeoutRetval;;0;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
+0x4401;HSPI_HalBusyRetval;;1;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
+0x4402;HSPI_HalErrorRetval;;2;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
+0x4501;HURT_UartReadFailure;;1;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
+0x4502;HURT_UartReadSizeMissmatch;;2;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
+0x4503;HURT_UartRxBufferTooSmall;;3;HAL_UART;fsfw/src/fsfw_hal/linux/uart/UartComIF.h
+0x4701;HGIO_UnknownGpioId;;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4702;HGIO_DriveGpioFailure;;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4703;HGIO_GpioTypeFailure;;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4704;HGIO_GpioInvalidInstance;;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4705;HGIO_GpioDuplicateDetected;;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4706;HGIO_GpioInitFailed;;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4707;HGIO_GpioGetValueFailed;;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4300;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4301;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
+0x4302;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4303;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4304;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4306;UXOS_PcloseCallError;;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x63a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;160;FILE_SYSTEM_HELPER;bsp_q7s/memory/FilesystemHelper.h
+0x63a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;161;FILE_SYSTEM_HELPER;bsp_q7s/memory/FilesystemHelper.h
+0x6900;SDMA_OpOngoing;;0;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
+0x6901;SDMA_AlreadyOn;;1;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
+0x6902;SDMA_AlreadyMounted;;2;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
+0x6903;SDMA_AlreadyOff;;3;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
+0x690a;SDMA_StatusFileNexists;;10;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
+0x690b;SDMA_StatusFileFormatInvalid;;11;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
+0x690c;SDMA_MountError;;12;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
+0x690d;SDMA_UnmountError;;13;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
+0x690e;SDMA_SystemCallError;;14;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
+0x690f;SDMA_PopenCallError;;15;SD_CARD_MANAGER;bsp_q7s/memory/SdCardManager.h
+0x6a00;SCBU_KeyNotFound;;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h

generators/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
  * @brief    Auto-generated event translation file. Contains 209 translations.
  * @details
- * Generated on: 2022-06-27 09:14:37
+ * Generated on: 2022-08-12 12:30:32
  */
 #include "translateEvents.h"
 

generators/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 132 translations.
- * Generated on: 2022-06-27 09:14:34
+ * Generated on: 2022-08-12 12:30:32
  */
 #include "translateObjects.h"
 

linux/CMakeLists.txt

@@ -1,7 +1,7 @@
 add_subdirectory(csp)
 add_subdirectory(utility)
 add_subdirectory(callbacks)
-add_subdirectory(boardtest)
+#add_subdirectory(boardtest)
 add_subdirectory(devices)
 add_subdirectory(fsfwconfig)
 add_subdirectory(obc)

linux/ObjectFactory.cpp

@@ -8,6 +8,7 @@
 #include <fsfw_hal/linux/spi/SpiCookie.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>
@@ -324,6 +325,8 @@ void ObjectFactory::createThermalController() {
   new ThermalController(objects::THERMAL_CONTROLLER, objects::NO_OBJECT);
 }
 
+void ObjectFactory::createAcsController() { new AcsController(objects::ACS_CONTROLLER); }
+
 void ObjectFactory::gpioChecker(ReturnValue_t result, std::string output) {
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "ObjectFactory: Adding GPIOs failed for " << output << std::endl;

linux/ObjectFactory.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <fsfw/hal/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
 #include <fsfw/returnvalues/HasReturnvaluesIF.h>
+#include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
 
 #include <string>
 
@@ -19,5 +19,6 @@ void createRtdComponents(std::string spiDev, GpioIF* gpioComIF, PowerSwitchIF* p
 void gpioChecker(ReturnValue_t result, std::string output);
 
 void createThermalController();
+void createAcsController();
 
 }  // namespace ObjectFactory

linux/devices/GPSHyperionLinuxController.cpp

@@ -53,22 +53,24 @@ ReturnValue_t GPSHyperionLinuxController::checkModeCommand(Mode_t mode, Submode_
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t GPSHyperionLinuxController::executeAction(ActionId_t actionId,
-                                                        MessageQueueId_t commandedBy,
-                                                        const uint8_t *data, size_t size) {
-  switch (actionId) {
-    case (GpsHyperion::TRIGGER_RESET_PIN_GNSS): {
-      if (resetCallback != nullptr) {
-        PoolReadGuard pg(&gpsSet);
-        // Set HK entries invalid
-        gpsSet.setValidity(false, true);
-        resetCallback(data, size, resetCallbackArgs);
-        return HasActionsIF::EXECUTION_FINISHED;
-      }
-      return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
-    }
+ModeDefinitionHelper GPSHyperionLinuxController::getModeDefinitionHelper() {
+  //TODO verify which modes are supported
+  return ModeDefinitionHelper::create<ControllerModes, DefaultSubmode>();
+}
+
+ReturnValue_t GPSHyperionLinuxController::executeAction(Action *action) {
+  return action->handle();
+}
+
+ReturnValue_t GPSHyperionLinuxController::handleAction(GPSHyperionLinuxAction * action) {
+  if (resetCallback != nullptr) {
+    PoolReadGuard pg(&gpsSet);
+    // Set HK entries invalid
+    gpsSet.setValidity(false, true);
+    resetCallback(static_cast<uint8_t>(action->gpsId.value), resetCallbackArgs);
+    return HasActionsIF::EXECUTION_FINISHED;
   }
-  return HasReturnvaluesIF::RETURN_OK;
+  return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
 }
 
 ReturnValue_t GPSHyperionLinuxController::initializeLocalDataPool(

linux/devices/GPSHyperionLinuxController.h

@@ -2,10 +2,11 @@
 #define MISSION_DEVICES_GPSHYPERIONHANDLER_H_
 
 #include "commonSubsystemIds.h"
+#include "devicedefinitions/GPSHyperionLinuxDefinitions.h"
 #include "fsfw/FSFW.h"
 #include "fsfw/controller/ExtendedControllerBase.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
-#include "mission/devices/devicedefinitions/GPSDefinitions.h"
+
 
 #ifdef FSFW_OSAL_LINUX
 #include <gps.h>
@@ -30,7 +31,7 @@ class GPSHyperionLinuxController : public ExtendedControllerBase {
                              bool debugHyperionGps = false);
   virtual ~GPSHyperionLinuxController();
 
-  using gpioResetFunction_t = ReturnValue_t (*)(const uint8_t* actionData, size_t len, void* args);
+  using gpioResetFunction_t = ReturnValue_t (*)(uint8_t gpsId, void* args);
 
   void setResetPinTriggerFunction(gpioResetFunction_t resetCallback, void* args);
   ReturnValue_t handleCommandMessage(CommandMessage* message) override;
@@ -38,8 +39,9 @@ class GPSHyperionLinuxController : public ExtendedControllerBase {
   LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
   ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                  uint32_t* msToReachTheMode) override;
-  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                              const uint8_t* data, size_t size) override;
+  ModeDefinitionHelper getModeDefinitionHelper() override;
+  ReturnValue_t executeAction(Action* action) override;
+  ReturnValue_t handleAction(GPSHyperionLinuxAction * action);
   ReturnValue_t initialize() override;
 
  protected:
@@ -65,6 +67,7 @@ class GPSHyperionLinuxController : public ExtendedControllerBase {
   int32_t noModeSetCntr = 0;
   uint32_t timeIsConstantCounter = 0;
   Countdown timeUpdateCd = Countdown(60);
+  GPSHyperionLinuxAction action = GPSHyperionLinuxAction(this);
 
   void readGpsDataFromGpsd();
 };

linux/devices/devicedefinitions/GPSHyperionLinuxDefinitions.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <fsfw/action/MinMaxParameter.h>
+#include <fsfw/action/TemplateAction.h>
+#include <fsfw/introspection/Enum.h>
+
+#include "mission/devices/devicedefinitions/GPSDefinitions.h"
+
+class GPSHyperionLinuxController;
+
+FSFW_ENUM(GPSHyperionLinuxCommands, DeviceCommandId_t,
+          ((TRIGGER_RESET_PIN_GNSS, GpsHyperion::TRIGGER_RESET_PIN_GNSS, "Trigger Reset Pin")))
+
+class GPSHyperionLinuxAction
+    : public TemplateAction<GPSHyperionLinuxController, GPSHyperionLinuxAction,
+                            GPSHyperionLinuxCommands> {
+ public:
+  FSFW_ENUM(GpsIDs, uint8_t, ((GPS_0, 0, "GPS 0"))((GPS_1, 1, "GPS 1")))
+  GPSHyperionLinuxAction(GPSHyperionLinuxController *owner)
+      : TemplateAction(owner, GPSHyperionLinuxCommands::TRIGGER_RESET_PIN_GNSS){};
+
+  Parameter<GpsIDs> gpsId = Parameter<GpsIDs>::createParameter(this, "GPS ID");
+};

linux/devices/devicedefinitions/PlocMPSoCCommonDefinitions.h

@@ -0,0 +1,646 @@
+#ifndef MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCCOMMONDEFINITIONS_H_
+#define MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCCOMMONDEFINITIONS_H_
+
+#include <fsfw/action/MinMaxParameter.h>
+#include <fsfw/action/TemplateAction.h>
+#include <fsfw/introspection/Enum.h>
+
+#include "MPSoCReturnValuesIF.h"
+#include "OBSWConfig.h"
+#include "eive/definitions.h"
+#include "fsfw/globalfunctions/CRC.h"
+#include "fsfw/serialize/SerializeAdapter.h"
+#include "fsfw/tmtcpacket/SpacePacket.h"
+
+
+namespace mpsoc {
+
+static const uint16_t SIZE_ACK_REPORT = 14;
+static const uint16_t SIZE_EXE_REPORT = 14;
+static const uint16_t SIZE_TM_MEM_READ_REPORT = 18;
+static const uint16_t SIZE_TM_CAM_CMD_RPT = 18;
+
+/**
+ * SpacePacket apids of PLOC telecommands and telemetry.
+ */
+namespace apid {
+static const uint16_t TC_REPLAY_START = 0x110;
+static const uint16_t TC_REPLAY_STOP = 0x111;
+static const uint16_t TC_REPLAY_WRITE_SEQUENCE = 0x112;
+static const uint16_t TC_DOWNLINK_PWR_ON = 0x113;
+static const uint16_t TC_MEM_WRITE = 0x114;
+static const uint16_t TC_MEM_READ = 0x115;
+static const uint16_t TC_FLASHWRITE = 0x117;
+static const uint16_t TC_FLASHFOPEN = 0x119;
+static const uint16_t TC_FLASHFCLOSE = 0x11A;
+static const uint16_t TC_FLASHDELETE = 0x11C;
+static const uint16_t TC_MODE_REPLAY = 0x11F;
+static const uint16_t TC_MODE_IDLE = 0x11E;
+static const uint16_t TC_DOWNLINK_PWR_OFF = 0x124;
+static const uint16_t TC_CAM_CMD_SEND = 0x12C;
+static const uint16_t TM_MEMORY_READ_REPORT = 0x404;
+static const uint16_t ACK_SUCCESS = 0x400;
+static const uint16_t ACK_FAILURE = 0x401;
+static const uint16_t EXE_SUCCESS = 0x402;
+static const uint16_t EXE_FAILURE = 0x403;
+static const uint16_t TM_CAM_CMD_RPT = 0x407;
+}  // namespace apid
+
+/** Offset from first byte in space packet to first byte of data field */
+static const uint8_t DATA_FIELD_OFFSET = 6;
+static const size_t MEM_READ_RPT_LEN_OFFSET = 10;
+static const char NULL_TERMINATOR = '\0';
+static const uint8_t MIN_SPACE_PACKET_LENGTH = 7;
+static const uint8_t SPACE_PACKET_HEADER_SIZE = 6;
+
+/**
+ * The size of payload data which will be forwarded to the requesting object. e.g. PUS Service
+ * 8.
+ */
+static const uint8_t SIZE_MEM_READ_RPT_FIX = 6;
+
+static const size_t MAX_FILENAME_SIZE = 256;
+
+/**
+ * PLOC space packet length for fixed size packets. This is the size of the whole packet data
+ * field. For the length field in the space packet this size will be substracted by one.
+ */
+static const uint16_t LENGTH_TC_MEM_WRITE = 12;
+static const uint16_t LENGTH_TC_MEM_READ = 8;
+
+static const size_t MAX_REPLY_SIZE = SpacePacket::PACKET_MAX_SIZE * 3;
+static const size_t MAX_COMMAND_SIZE = SpacePacket::PACKET_MAX_SIZE;
+static const size_t MAX_DATA_SIZE = 1016;
+
+/**
+ * The replay write sequence command has a maximum delay for the execution report which amounts to
+ * 30 seconds. (80 cycles * 0.5 seconds = 40 seconds).
+ */
+static const uint16_t TC_WRITE_SEQ_EXECUTION_DELAY = 80;
+// Requires approx. 2 seconds for execution. 8 => 4 seconds
+static const uint16_t TC_DOWNLINK_PWR_ON_EXECUTION_DELAY = 8;
+
+namespace status_code {
+static const uint16_t UNKNOWN_APID = 0x5DD;
+static const uint16_t INCORRECT_LENGTH = 0x5DE;
+static const uint16_t INCORRECT_CRC = 0x5DF;
+static const uint16_t INCORRECT_PKT_SEQ_CNT = 0x5E0;
+static const uint16_t TC_NOT_ALLOWED_IN_MODE = 0x5E1;
+static const uint16_t TC_EXEUTION_DISABLED = 0x5E2;
+static const uint16_t FLASH_MOUNT_FAILED = 0x5E3;
+static const uint16_t FLASH_FILE_ALREADY_CLOSED = 0x5E4;
+static const uint16_t FLASH_FILE_OPEN_FAILED = 0x5E5;
+static const uint16_t FLASH_FILE_ALREDY_OPEN = 0x5E6;
+static const uint16_t FLASH_FILE_NOT_OPEN = 0x5E7;
+static const uint16_t FLASH_UNMOUNT_FAILED = 0x5E8;
+static const uint16_t HEAP_ALLOCATION_FAILED = 0x5E9;
+static const uint16_t INVALID_PARAMETER = 0x5EA;
+static const uint16_t NOT_INITIALIZED = 0x5EB;
+static const uint16_t REBOOT_IMMINENT = 0x5EC;
+static const uint16_t CORRUPT_DATA = 0x5ED;
+static const uint16_t FLASH_CORRECTABLE_MISMATCH = 0x5EE;
+static const uint16_t FLASH_UNCORRECTABLE_MISMATCH = 0x5EF;
+static const uint16_t RESERVED_0 = 0x5F0;
+static const uint16_t RESERVED_1 = 0x5F1;
+static const uint16_t RESERVED_2 = 0x5F2;
+static const uint16_t RESERVED_3 = 0x5F3;
+static const uint16_t RESERVED_4 = 0x5F4;
+}  // namespace status_code
+
+/**
+ * @brief   Abstract base class for TC space packet of MPSoC.
+ */
+class TcBase : public SpacePacket, public MPSoCReturnValuesIF {
+ public:
+  // Initial length field of space packet. Will always be updated when packet is created.
+  static const uint16_t INIT_LENGTH = 1;
+
+  /**
+   * @brief    Constructor
+   *
+   * @param sequenceCount Sequence count of space packet which will be incremented with each
+   *        sent and received packets.
+   */
+  TcBase(uint16_t apid, uint16_t sequenceCount)
+      : SpacePacket(INIT_LENGTH, true, apid, sequenceCount) {}
+
+  /**
+   * @brief   Function to initialize the space packet
+   *
+   * @param commandData       Pointer to command specific data
+   * @param commandDataLen    Length of command data
+   *
+   * @return  RETURN_OK if packet creation was successful, otherwise error return value
+   */
+  virtual ReturnValue_t createPacket(void *action) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = initPacket(action);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    return result;
+  }
+
+ protected:
+  /**
+   * @brief   Must be overwritten by the child class to define the command specific parameters
+   *
+   * @param commandData       Pointer to received command data
+   * @param commandDataLen    Length of received command data
+   */
+  virtual ReturnValue_t initPacket(void *action) {
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  /**
+   * @brief   Calculates and adds the CRC
+   */
+  ReturnValue_t addCrc() {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    size_t serializedSize = 0;
+    uint32_t full_size = getFullSize();
+    uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
+    result = SerializeAdapter::serialize<uint16_t>(
+        &crc, this->localData.byteStream + full_size - CRC_SIZE, &serializedSize, sizeof(crc),
+        SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      sif::debug << "TcBase::addCrc: Failed to serialize crc field" << std::endl;
+    }
+    return result;
+  }
+};
+
+/**
+ * @brief   Class for handling tm replies of the PLOC MPSoC.
+ */
+class TmPacket : public SpacePacket, public MPSoCReturnValuesIF {
+ public:
+  /**
+   * @brief   Constructor creates idle packet and sets length field to maximum allowed size.
+   */
+  TmPacket() : SpacePacket(PACKET_MAX_SIZE) {}
+
+  ReturnValue_t checkCrc() {
+    uint8_t *crcPtr = this->getPacketData() + this->getPacketDataLength() - 1;
+    uint16_t receivedCrc = *(crcPtr) << 8 | *(crcPtr + 1);
+    uint16_t recalculatedCrc =
+        CRC::crc16ccitt(this->localData.byteStream, this->getFullSize() - CRC_SIZE);
+    if (recalculatedCrc != receivedCrc) {
+      return CRC_FAILURE;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   This class helps to build the memory read command for the PLOC.
+ */
+class TcMemRead : public TcBase {
+ public:
+  /**
+   * @brief   Constructor
+   */
+  TcMemRead(uint16_t sequenceCount) : TcBase(apid::TC_MEM_READ, sequenceCount) {
+    this->setPacketDataLength(PACKET_LENGTH);
+  }
+
+  uint16_t getMemLen() const { return memLen; }
+
+ protected:
+  ReturnValue_t initPacket(const uint8_t *commandData, size_t commandDataLen) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = lengthCheck(commandDataLen);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    std::memcpy(this->localData.fields.buffer, commandData, MEM_ADDRESS_SIZE);
+    std::memcpy(this->localData.fields.buffer + MEM_ADDRESS_SIZE, commandData + MEM_ADDRESS_SIZE,
+                MEM_LEN_SIZE);
+    size_t size = sizeof(memLen);
+    const uint8_t *memLenPtr = commandData + MEM_ADDRESS_SIZE;
+    result =
+        SerializeAdapter::deSerialize(&memLen, &memLenPtr, &size, SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    return result;
+  }
+
+ private:
+  static const size_t COMMAND_LENGTH = 6;
+  static const size_t MEM_ADDRESS_SIZE = 4;
+  static const size_t MEM_LEN_SIZE = 2;
+  static const uint16_t PACKET_LENGTH = 7;
+
+  uint16_t memLen = 0;
+
+  ReturnValue_t lengthCheck(size_t commandDataLen) {
+    if (commandDataLen != COMMAND_LENGTH) {
+      return INVALID_LENGTH;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+
+
+/**
+ * @brief   Class to help creation of flash fopen command.
+ */
+class FlashFopen : public TcBase {
+ public:
+  FlashFopen(uint16_t sequenceCount) : TcBase(apid::TC_FLASHFOPEN, sequenceCount) {}
+
+  static const char APPEND = 'a';
+  static const char WRITE = 'w';
+  static const char READ = 'r';
+
+  ReturnValue_t createPacket(std::string filename, char accessMode_) {
+    accessMode = accessMode_;
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    size_t nameSize = filename.size();
+    std::memcpy(this->getPacketData(), filename.c_str(), nameSize);
+    *(this->getPacketData() + nameSize) = NULL_TERMINATOR;
+    std::memcpy(this->getPacketData() + nameSize + sizeof(NULL_TERMINATOR), &accessMode,
+                sizeof(accessMode));
+    this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + sizeof(accessMode) + CRC_SIZE -
+                              1);
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    return result;
+  }
+
+ private:
+  char accessMode = APPEND;
+};
+
+/**
+ * @brief   Class to help creation of flash fclose command.
+ */
+class FlashFclose : public TcBase {
+ public:
+  FlashFclose(uint16_t sequenceCount) : TcBase(apid::TC_FLASHFCLOSE, sequenceCount) {}
+
+  ReturnValue_t createPacket(std::string filename) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    size_t nameSize = filename.size();
+    std::memcpy(this->getPacketData(), filename.c_str(), nameSize);
+    *(this->getPacketData() + nameSize) = NULL_TERMINATOR;
+    this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1);
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    return result;
+  }
+};
+
+/**
+ * @brief   Class to build flash write space packet.
+ */
+class TcFlashWrite : public TcBase {
+ public:
+  TcFlashWrite(uint16_t sequenceCount) : TcBase(apid::TC_FLASHWRITE, sequenceCount) {}
+
+  ReturnValue_t createPacket(const uint8_t *writeData, uint32_t writeLen_) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    writeLen = writeLen_;
+    if (writeLen > MAX_DATA_SIZE) {
+      sif::debug << "FlashWrite::createPacket: Command data too big" << std::endl;
+      return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    size_t serializedSize = 0;
+    result =
+        SerializeAdapter::serialize<uint32_t>(&writeLen, this->getPacketData(), &serializedSize,
+                                              sizeof(writeLen), SerializeIF::Endianness::BIG);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    std::memcpy(this->getPacketData() + sizeof(writeLen), writeData, writeLen);
+    this->setPacketDataLength(static_cast<uint16_t>(writeLen + CRC_SIZE - 1));
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+ private:
+  uint32_t writeLen = 0;
+};
+
+/**
+ * @brief   Class to help creation of flash delete command.
+ */
+class TcFlashDelete : public TcBase {
+ public:
+  TcFlashDelete(uint16_t sequenceCount) : TcBase(apid::TC_FLASHDELETE, sequenceCount) {}
+
+  ReturnValue_t createPacket(std::string filename) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    size_t nameSize = filename.size();
+    std::memcpy(this->getPacketData(), filename.c_str(), nameSize);
+    *(this->getPacketData() + nameSize) = NULL_TERMINATOR;
+    this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1);
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    return result;
+  }
+};
+
+/**
+ * @brief   Class to build replay stop space packet.
+ */
+class TcReplayStop : public TcBase {
+ public:
+  TcReplayStop(uint16_t sequenceCount) : TcBase(apid::TC_REPLAY_STOP, sequenceCount) {}
+
+  ReturnValue_t createPacket() {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    this->setPacketDataLength(static_cast<uint16_t>(CRC_SIZE - 1));
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   This class helps to build the replay start command.
+ */
+class TcReplayStart : public TcBase {
+ public:
+  /**
+   * @brief   Constructor
+   */
+  TcReplayStart(uint16_t sequenceCount) : TcBase(apid::TC_REPLAY_START, sequenceCount) {}
+
+ protected:
+  ReturnValue_t initPacket(const uint8_t *commandData, size_t commandDataLen) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = lengthCheck(commandDataLen);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    result = checkData(*commandData);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    std::memcpy(this->localData.fields.buffer, commandData, commandDataLen);
+    this->setPacketDataLength(commandDataLen + CRC_SIZE - 1);
+    return result;
+  }
+
+ private:
+  static const size_t COMMAND_DATA_LENGTH = 1;
+  static const uint8_t REPEATING = 0;
+  static const uint8_t ONCE = 1;
+
+  ReturnValue_t lengthCheck(size_t commandDataLen) {
+    if (commandDataLen != COMMAND_DATA_LENGTH) {
+      sif::warning << "TcReplayStart: Command has invalid length " << commandDataLen << std::endl;
+      return INVALID_LENGTH;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  ReturnValue_t checkData(uint8_t replay) {
+    if (replay != REPEATING && replay != ONCE) {
+      sif::warning << "TcReplayStart::checkData: Invalid replay value" << std::endl;
+      return INVALID_PARAMETER;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   This class helps to build downlink power on command.
+ */
+class TcDownlinkPwrOn : public TcBase {
+ public:
+  /**
+   * @brief   Constructor
+   */
+  TcDownlinkPwrOn(uint16_t sequenceCount) : TcBase(apid::TC_DOWNLINK_PWR_ON, sequenceCount) {}
+
+ protected:
+  ReturnValue_t initPacket(const uint8_t *commandData, size_t commandDataLen) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = lengthCheck(commandDataLen);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    result = modeCheck(*commandData);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    result = laneRateCheck(*(commandData + 1));
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    std::memcpy(this->localData.fields.buffer, commandData, commandDataLen);
+    std::memcpy(this->localData.fields.buffer + commandDataLen, &MAX_AMPLITUDE,
+                sizeof(MAX_AMPLITUDE));
+    this->setPacketDataLength(commandDataLen + sizeof(MAX_AMPLITUDE) + CRC_SIZE - 1);
+    return result;
+  }
+
+ private:
+  static const uint8_t INTERFACE_ID = CLASS_ID::DWLPWRON_CMD;
+
+  //! [EXPORT] : [COMMENT] Received command has invalid JESD mode (valid modes are 0 - 5)
+  static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0xE0);
+  //! [EXPORT] : [COMMENT] Received command has invalid lane rate (valid lane rate are 0 - 9)
+  static const ReturnValue_t INVALID_LANE_RATE = MAKE_RETURN_CODE(0xE1);
+
+  static const size_t COMMAND_DATA_LENGTH = 2;
+  static const uint8_t MAX_MODE = 5;
+  static const uint8_t MAX_LANE_RATE = 9;
+  static const uint16_t MAX_AMPLITUDE = 0;
+
+  ReturnValue_t lengthCheck(size_t commandDataLen) {
+    if (commandDataLen != COMMAND_DATA_LENGTH) {
+      sif::warning << "TcDownlinkPwrOn: Command has invalid length " << commandDataLen << std::endl;
+      return INVALID_LENGTH;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  ReturnValue_t modeCheck(uint8_t mode) {
+    if (mode > MAX_MODE) {
+      sif::warning << "TcDwonlinkPwrOn::modeCheck: Invalid JESD mode" << std::endl;
+      return INVALID_MODE;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  ReturnValue_t laneRateCheck(uint8_t laneRate) {
+    if (laneRate > MAX_LANE_RATE) {
+      sif::warning << "TcReplayStart::laneRateCheck: Invalid lane rate" << std::endl;
+      return INVALID_LANE_RATE;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   Class to build replay stop space packet.
+ */
+class TcDownlinkPwrOff : public TcBase {
+ public:
+  TcDownlinkPwrOff(uint16_t sequenceCount) : TcBase(apid::TC_DOWNLINK_PWR_OFF, sequenceCount) {}
+
+  ReturnValue_t createPacket() {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    this->setPacketDataLength(static_cast<uint16_t>(CRC_SIZE - 1));
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   This class helps to build the replay start command.
+ */
+class TcReplayWriteSeq : public TcBase {
+ public:
+  /**
+   * @brief   Constructor
+   */
+  TcReplayWriteSeq(uint16_t sequenceCount)
+      : TcBase(apid::TC_REPLAY_WRITE_SEQUENCE, sequenceCount) {}
+
+ protected:
+  ReturnValue_t initPacket(const uint8_t *commandData, size_t commandDataLen) {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = lengthCheck(commandDataLen);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    std::memcpy(this->localData.fields.buffer, commandData, commandDataLen);
+    *(this->localData.fields.buffer + commandDataLen) = NULL_TERMINATOR;
+    this->setPacketDataLength(commandDataLen + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1);
+    return result;
+  }
+
+ private:
+  static const size_t USE_DECODING_LENGTH = 1;
+
+  ReturnValue_t lengthCheck(size_t commandDataLen) {
+    if (commandDataLen > USE_DECODING_LENGTH + MAX_FILENAME_SIZE) {
+      sif::warning << "TcReplayWriteSeq: Command has invalid length " << commandDataLen
+                   << std::endl;
+      return INVALID_LENGTH;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   Helps to extract the fields of the flash write command from the PUS packet.
+ */
+class FlashWritePusCmd : public MPSoCReturnValuesIF {
+ public:
+  FlashWritePusCmd(){};
+
+  ReturnValue_t extractFields(const uint8_t *commandData, size_t commandDataLen) {
+    if (commandDataLen > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE + MAX_FILENAME_SIZE)) {
+      return INVALID_LENGTH;
+    }
+    obcFile = std::string(reinterpret_cast<const char *>(commandData));
+    if (obcFile.size() > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE)) {
+      return FILENAME_TOO_LONG;
+    }
+    mpsocFile = std::string(
+        reinterpret_cast<const char *>(commandData + obcFile.size() + SIZE_NULL_TERMINATOR));
+    if (mpsocFile.size() > MAX_FILENAME_SIZE) {
+      return MPSOC_FILENAME_TOO_LONG;
+    }
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+  std::string getObcFile() { return obcFile; }
+
+  std::string getMPSoCFile() { return mpsocFile; }
+
+ private:
+  static const size_t SIZE_NULL_TERMINATOR = 1;
+  std::string obcFile = "";
+  std::string mpsocFile = "";
+};
+
+/**
+ * @brief   Class to build replay stop space packet.
+ */
+class TcModeReplay : public TcBase {
+ public:
+  TcModeReplay(uint16_t sequenceCount) : TcBase(apid::TC_MODE_REPLAY, sequenceCount) {}
+
+  ReturnValue_t createPacket() {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    this->setPacketDataLength(static_cast<uint16_t>(CRC_SIZE - 1));
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+/**
+ * @brief   Class to build mode idle command
+ */
+class TcModeIdle : public TcBase {
+ public:
+  TcModeIdle(uint16_t sequenceCount) : TcBase(apid::TC_MODE_IDLE, sequenceCount) {}
+
+  ReturnValue_t createPacket() {
+    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+    result = addCrc();
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+    this->setPacketDataLength(static_cast<uint16_t>(CRC_SIZE - 1));
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+};
+
+class TcCamcmdSend : public TcBase {
+ public:
+  TcCamcmdSend(uint16_t sequenceCount) : TcBase(apid::TC_CAM_CMD_SEND, sequenceCount) {}
+
+ protected:
+  ReturnValue_t initPacket(const uint8_t *commandData, size_t commandDataLen) {
+    if (commandDataLen > MAX_DATA_LENGTH) {
+      return INVALID_LENGTH;
+    }
+    uint16_t dataLen = static_cast<uint16_t>(commandDataLen + sizeof(CARRIAGE_RETURN));
+    size_t size = sizeof(dataLen);
+    SerializeAdapter::serialize(&dataLen, this->getPacketData(), &size, sizeof(dataLen),
+                                SerializeIF::Endianness::BIG);
+    std::memcpy(this->getPacketData() + sizeof(dataLen), commandData, commandDataLen);
+    *(this->getPacketData() + sizeof(dataLen) + commandDataLen) = CARRIAGE_RETURN;
+    uint16_t trueLength = sizeof(dataLen) + commandDataLen + sizeof(CARRIAGE_RETURN) + CRC_SIZE;
+    this->setPacketDataLength(trueLength - 1);
+    return HasReturnvaluesIF::RETURN_OK;
+  }
+
+ private:
+  static const uint8_t MAX_DATA_LENGTH = 10;
+  static const uint8_t CARRIAGE_RETURN = 0xD;
+};
+
+}  // namespace mpsoc
+
+#endif /* MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCCOMMONDEFINITIONS_H_ */

linux/devices/devicedefinitions/PlocMPSoCDefinitions.h

@@ -1,271 +1,146 @@
 #ifndef MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
 #define MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_
 
+#include <fsfw/action/MinMaxParameter.h>
+#include <fsfw/action/TemplateAction.h>
+#include <fsfw/introspection/Enum.h>
+
 #include "MPSoCReturnValuesIF.h"
 #include "OBSWConfig.h"
+#include "PlocMPSoCCommonDefinitions.h"
 #include "eive/definitions.h"
 #include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/serialize/SerializeAdapter.h"
 #include "fsfw/tmtcpacket/SpacePacket.h"
 
+class PlocMPSoCHandler;
+
+FSFW_ENUM(PlocMpSoCCommands, DeviceCommandId_t,
+          ((NONE, 0, "No Command"))((TC_MEM_WRITE, 1, "Write to Memory"))(
+              (TC_MEM_READ, 2, "Read from Memory"))((ACK_REPORT, 3, ""))((EXE_REPORT, 5, ""))(
+              (TM_MEMORY_READ_REPORT, 6, ""))((TC_FLASHWRITE, 9, "Write Flash"))(
+              (TC_FLASHDELETE, 10, "Delete Flash"))((TC_REPLAY_START, 11, "Start Replay"))(
+              (TC_REPLAY_STOP, 12, "Stop Replay"))((TC_REPLAY_WRITE_SEQUENCE, 13,
+                                                    "Write Sequence"))((TC_DOWNLINK_PWR_ON, 14,
+                                                                        "Set Downlink Power On"))(
+              (TC_DOWNLINK_PWR_OFF, 15, "Set Downlink Power Off"))((TC_MODE_REPLAY, 16,
+                                                                    "Set Replay Mode"))(
+              (TC_CAM_CMD_SEND, 17, "Set Replay Mode"))((TC_MODE_IDLE, 18, "Set Idle Mode"))(
+              (TM_CAM_CMD_RPT, 19, ""))((SET_UART_TX_TRISTATE, 20, "Set UART TX to Tristate"))(
+              (RELEASE_UART_TX, 21, "Release UART TX"))((OBSW_RESET_SEQ_COUNT, 50,
+                                                         "Reset OBSW Reset Sequence Count")))
+
+class PlocMpSoCMemWriteAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCMemWriteAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCMemWriteAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::TC_MEM_WRITE){};
+
+      Parameter<uint32_t> address = Parameter<uint32_t>::createParameter(this, "Memory Address");
+      Parameter<uint32_t> memoryData = Parameter<uint32_t>::createParameter(this, "Data to be written");
+};
+
+class PlocMpSoCMemReadAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCMemReadAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCMemReadAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::TC_MEM_READ){};
+};
+
+class PlocMpSoCFlashDeleteAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCFlashDeleteAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCFlashDeleteAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::TC_FLASHDELETE){};
+};
+
+class PlocMpSoCReplayStartAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCReplayStartAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCReplayStartAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::TC_REPLAY_START){};
+};
+
+class PlocMpSoCReplayStopAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCReplayStopAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCReplayStopAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::TC_REPLAY_STOP){};
+};
+
+class PlocMpSoCReplayWriteSequenceAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCReplayWriteSequenceAction,
+                            PlocMpSoCCommands> {
+ public:
+  PlocMpSoCReplayWriteSequenceAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::TC_REPLAY_WRITE_SEQUENCE){};
+};
+
+class PlocMpSoCDownlinkPwrOnAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCDownlinkPwrOnAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCDownlinkPwrOnAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::TC_DOWNLINK_PWR_ON){};
+};
+
+class PlocMpSoCDownlinkPwrOffAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCDownlinkPwrOffAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCDownlinkPwrOffAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::TC_DOWNLINK_PWR_OFF){};
+};
+
+class PlocMpSoCModeReplayAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCModeReplayAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCModeReplayAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::TC_MODE_REPLAY){};
+};
+
+class PlocMpSoCCamCmdSendAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCCamCmdSendAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCCamCmdSendAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::TC_CAM_CMD_SEND){};
+};
+
+class PlocMpSoCModeIdleAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCModeIdleAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCModeIdleAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::TC_MODE_IDLE){};
+};
+
+class PlocMpSoCFlashWriteAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCFlashWriteAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCFlashWriteAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::TC_FLASHWRITE){};
+};
+
+class PlocMpSoCUartTxTristateAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCUartTxTristateAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCUartTxTristateAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::SET_UART_TX_TRISTATE){};
+};
+
+class PlocMpSoCReleaseUartTxAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCReleaseUartTxAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCReleaseUartTxAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::RELEASE_UART_TX){};
+};
+
+class PlocMpSoCObswResetSeqCountAction
+    : public TemplateAction<PlocMPSoCHandler, PlocMpSoCObswResetSeqCountAction, PlocMpSoCCommands> {
+ public:
+  PlocMpSoCObswResetSeqCountAction(PlocMPSoCHandler *owner)
+      : TemplateAction(owner, PlocMpSoCCommands::OBSW_RESET_SEQ_COUNT){};
+};
+
 namespace mpsoc {
 
-static const DeviceCommandId_t NONE = 0;
-static const DeviceCommandId_t TC_MEM_WRITE = 1;
-static const DeviceCommandId_t TC_MEM_READ = 2;
-static const DeviceCommandId_t ACK_REPORT = 3;
-static const DeviceCommandId_t EXE_REPORT = 5;
-static const DeviceCommandId_t TM_MEMORY_READ_REPORT = 6;
-static const DeviceCommandId_t TC_FLASHFOPEN = 7;
-static const DeviceCommandId_t TC_FLASHFCLOSE = 8;
-static const DeviceCommandId_t TC_FLASHWRITE = 9;
-static const DeviceCommandId_t TC_FLASHDELETE = 10;
-static const DeviceCommandId_t TC_REPLAY_START = 11;
-static const DeviceCommandId_t TC_REPLAY_STOP = 12;
-static const DeviceCommandId_t TC_REPLAY_WRITE_SEQUENCE = 13;
-static const DeviceCommandId_t TC_DOWNLINK_PWR_ON = 14;
-static const DeviceCommandId_t TC_DOWNLINK_PWR_OFF = 15;
-static const DeviceCommandId_t TC_MODE_REPLAY = 16;
-static const DeviceCommandId_t TC_CAM_CMD_SEND = 17;
-static const DeviceCommandId_t TC_MODE_IDLE = 18;
-static const DeviceCommandId_t TM_CAM_CMD_RPT = 19;
-static const DeviceCommandId_t SET_UART_TX_TRISTATE = 20;
-static const DeviceCommandId_t RELEASE_UART_TX = 21;
-
-// Will reset the sequence count of the OBSW
-static const DeviceCommandId_t OBSW_RESET_SEQ_COUNT = 50;
-
-static const uint16_t SIZE_ACK_REPORT = 14;
-static const uint16_t SIZE_EXE_REPORT = 14;
-static const uint16_t SIZE_TM_MEM_READ_REPORT = 18;
-static const uint16_t SIZE_TM_CAM_CMD_RPT = 18;
-
-/**
- * SpacePacket apids of PLOC telecommands and telemetry.
- */
-namespace apid {
-static const uint16_t TC_REPLAY_START = 0x110;
-static const uint16_t TC_REPLAY_STOP = 0x111;
-static const uint16_t TC_REPLAY_WRITE_SEQUENCE = 0x112;
-static const uint16_t TC_DOWNLINK_PWR_ON = 0x113;
-static const uint16_t TC_MEM_WRITE = 0x114;
-static const uint16_t TC_MEM_READ = 0x115;
-static const uint16_t TC_FLASHWRITE = 0x117;
-static const uint16_t TC_FLASHFOPEN = 0x119;
-static const uint16_t TC_FLASHFCLOSE = 0x11A;
-static const uint16_t TC_FLASHDELETE = 0x11C;
-static const uint16_t TC_MODE_REPLAY = 0x11F;
-static const uint16_t TC_MODE_IDLE = 0x11E;
-static const uint16_t TC_DOWNLINK_PWR_OFF = 0x124;
-static const uint16_t TC_CAM_CMD_SEND = 0x12C;
-static const uint16_t TM_MEMORY_READ_REPORT = 0x404;
-static const uint16_t ACK_SUCCESS = 0x400;
-static const uint16_t ACK_FAILURE = 0x401;
-static const uint16_t EXE_SUCCESS = 0x402;
-static const uint16_t EXE_FAILURE = 0x403;
-static const uint16_t TM_CAM_CMD_RPT = 0x407;
-}  // namespace apid
-
-/** Offset from first byte in space packet to first byte of data field */
-static const uint8_t DATA_FIELD_OFFSET = 6;
-static const size_t MEM_READ_RPT_LEN_OFFSET = 10;
-static const char NULL_TERMINATOR = '\0';
-static const uint8_t MIN_SPACE_PACKET_LENGTH = 7;
-static const uint8_t SPACE_PACKET_HEADER_SIZE = 6;
-
-/**
- * The size of payload data which will be forwarded to the requesting object. e.g. PUS Service
- * 8.
- */
-static const uint8_t SIZE_MEM_READ_RPT_FIX = 6;
-
-static const size_t MAX_FILENAME_SIZE = 256;
-
-/**
- * PLOC space packet length for fixed size packets. This is the size of the whole packet data
- * field. For the length field in the space packet this size will be substracted by one.
- */
-static const uint16_t LENGTH_TC_MEM_WRITE = 12;
-static const uint16_t LENGTH_TC_MEM_READ = 8;
-
-static const size_t MAX_REPLY_SIZE = SpacePacket::PACKET_MAX_SIZE * 3;
-static const size_t MAX_COMMAND_SIZE = SpacePacket::PACKET_MAX_SIZE;
-static const size_t MAX_DATA_SIZE = 1016;
-
-/**
- * The replay write sequence command has a maximum delay for the execution report which amounts to
- * 30 seconds. (80 cycles * 0.5 seconds = 40 seconds).
- */
-static const uint16_t TC_WRITE_SEQ_EXECUTION_DELAY = 80;
-// Requires approx. 2 seconds for execution. 8 => 4 seconds
-static const uint16_t TC_DOWNLINK_PWR_ON_EXECUTION_DELAY = 8;
-
-namespace status_code {
-static const uint16_t UNKNOWN_APID = 0x5DD;
-static const uint16_t INCORRECT_LENGTH = 0x5DE;
-static const uint16_t INCORRECT_CRC = 0x5DF;
-static const uint16_t INCORRECT_PKT_SEQ_CNT = 0x5E0;
-static const uint16_t TC_NOT_ALLOWED_IN_MODE = 0x5E1;
-static const uint16_t TC_EXEUTION_DISABLED = 0x5E2;
-static const uint16_t FLASH_MOUNT_FAILED = 0x5E3;
-static const uint16_t FLASH_FILE_ALREADY_CLOSED = 0x5E4;
-static const uint16_t FLASH_FILE_OPEN_FAILED = 0x5E5;
-static const uint16_t FLASH_FILE_ALREDY_OPEN = 0x5E6;
-static const uint16_t FLASH_FILE_NOT_OPEN = 0x5E7;
-static const uint16_t FLASH_UNMOUNT_FAILED = 0x5E8;
-static const uint16_t HEAP_ALLOCATION_FAILED = 0x5E9;
-static const uint16_t INVALID_PARAMETER = 0x5EA;
-static const uint16_t NOT_INITIALIZED = 0x5EB;
-static const uint16_t REBOOT_IMMINENT = 0x5EC;
-static const uint16_t CORRUPT_DATA = 0x5ED;
-static const uint16_t FLASH_CORRECTABLE_MISMATCH = 0x5EE;
-static const uint16_t FLASH_UNCORRECTABLE_MISMATCH = 0x5EF;
-static const uint16_t RESERVED_0 = 0x5F0;
-static const uint16_t RESERVED_1 = 0x5F1;
-static const uint16_t RESERVED_2 = 0x5F2;
-static const uint16_t RESERVED_3 = 0x5F3;
-static const uint16_t RESERVED_4 = 0x5F4;
-}  // namespace status_code
-
-/**
- * @brief   Abstract base class for TC space packet of MPSoC.
- */
-class TcBase : public SpacePacket, public MPSoCReturnValuesIF {
- public:
-  // Initial length field of space packet. Will always be updated when packet is created.
-  static const uint16_t INIT_LENGTH = 1;
-
-  /**
-   * @brief    Constructor
-   *
-   * @param sequenceCount Sequence count of space packet which will be incremented with each
-   *        sent and received packets.
-   */
-  TcBase(uint16_t apid, uint16_t sequenceCount)
-      : SpacePacket(INIT_LENGTH, true, apid, sequenceCount) {}
-
-  /**
-   * @brief   Function to initialize the space packet
-   *
-   * @param commandData       Pointer to command specific data
-   * @param commandDataLen    Length of command data
-   *
-   * @return  RETURN_OK if packet creation was successful, otherwise error return value
-   */
-  virtual ReturnValue_t createPacket(const uint8_t* commandData, size_t commandDataLen) {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    result = initPacket(commandData, commandDataLen);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    result = addCrc();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    return result;
-  }
-
- protected:
-  /**
-   * @brief   Must be overwritten by the child class to define the command specific parameters
-   *
-   * @param commandData       Pointer to received command data
-   * @param commandDataLen    Length of received command data
-   */
-  virtual ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-
-  /**
-   * @brief   Calculates and adds the CRC
-   */
-  ReturnValue_t addCrc() {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    size_t serializedSize = 0;
-    uint32_t full_size = getFullSize();
-    uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
-    result = SerializeAdapter::serialize<uint16_t>(
-        &crc, this->localData.byteStream + full_size - CRC_SIZE, &serializedSize, sizeof(crc),
-        SerializeIF::Endianness::BIG);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      sif::debug << "TcBase::addCrc: Failed to serialize crc field" << std::endl;
-    }
-    return result;
-  }
-};
-
-/**
- * @brief   Class for handling tm replies of the PLOC MPSoC.
- */
-class TmPacket : public SpacePacket, public MPSoCReturnValuesIF {
- public:
-  /**
-   * @brief   Constructor creates idle packet and sets length field to maximum allowed size.
-   */
-  TmPacket() : SpacePacket(PACKET_MAX_SIZE) {}
-
-  ReturnValue_t checkCrc() {
-    uint8_t* crcPtr = this->getPacketData() + this->getPacketDataLength() - 1;
-    uint16_t receivedCrc = *(crcPtr) << 8 | *(crcPtr + 1);
-    uint16_t recalculatedCrc =
-        CRC::crc16ccitt(this->localData.byteStream, this->getFullSize() - CRC_SIZE);
-    if (recalculatedCrc != receivedCrc) {
-      return CRC_FAILURE;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-};
-
-/**
- * @brief   This class helps to build the memory read command for the PLOC.
- */
-class TcMemRead : public TcBase {
- public:
-  /**
-   * @brief   Constructor
-   */
-  TcMemRead(uint16_t sequenceCount) : TcBase(apid::TC_MEM_READ, sequenceCount) {
-    this->setPacketDataLength(PACKET_LENGTH);
-  }
-
-  uint16_t getMemLen() const { return memLen; }
-
- protected:
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    result = lengthCheck(commandDataLen);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    std::memcpy(this->localData.fields.buffer, commandData, MEM_ADDRESS_SIZE);
-    std::memcpy(this->localData.fields.buffer + MEM_ADDRESS_SIZE, commandData + MEM_ADDRESS_SIZE,
-                MEM_LEN_SIZE);
-    size_t size = sizeof(memLen);
-    const uint8_t* memLenPtr = commandData + MEM_ADDRESS_SIZE;
-    result =
-        SerializeAdapter::deSerialize(&memLen, &memLenPtr, &size, SerializeIF::Endianness::BIG);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    return result;
-  }
-
- private:
-  static const size_t COMMAND_LENGTH = 6;
-  static const size_t MEM_ADDRESS_SIZE = 4;
-  static const size_t MEM_LEN_SIZE = 2;
-  static const uint16_t PACKET_LENGTH = 7;
-
-  uint16_t memLen = 0;
-
-  ReturnValue_t lengthCheck(size_t commandDataLen) {
-    if (commandDataLen != COMMAND_LENGTH) {
-      return INVALID_LENGTH;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-};
-
 /**
  * @brief   This class helps to generate the space packet to write data to a memory address within
  *          the PLOC.
@@ -278,23 +153,31 @@ class TcMemWrite : public TcBase {
   TcMemWrite(uint16_t sequenceCount) : TcBase(apid::TC_MEM_WRITE, sequenceCount) {}
 
  protected:
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
+  ReturnValue_t initPacket(void *actionIn) {
+    auto action = (PlocMpSoCMemWriteAction *)(actionIn); //TODO
     ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    result = lengthCheck(commandDataLen);
+    // faking until framework code is ready
+    // uint16_t length = action->memoryData.length;
+    uint16_t dataLength = 1;
+    result = lengthCheck(dataLength);
     if (result != HasReturnvaluesIF::RETURN_OK) {
       return result;
     }
-    std::memcpy(this->localData.fields.buffer, commandData, commandDataLen);
-    uint16_t memLen =
-        *(commandData + MEM_ADDRESS_SIZE) << 8 | *(commandData + MEM_ADDRESS_SIZE + 1);
-    this->setPacketDataLength(memLen * 4 + FIX_LENGTH - 1);
+    uint8_t *pointer = this->localData.fields.buffer;
+    size_t size = 0;
+    size_t maxSize = PACKET_MAX_SIZE;
+    SerializeAdapter::serialize(&action->address.value, &pointer, &size, maxSize,
+                                SerializeIF::Endianness::BIG);
+    SerializeAdapter::serialize(&dataLength, &pointer, &size, maxSize,
+                                SerializeIF::Endianness::BIG);
+    std::memcpy(pointer, &action->memoryData.value, dataLength);
+    this->setPacketDataLength(dataLength * sizeof(action->memoryData.value) + FIX_LENGTH - 1);
     return result;
   }
 
  private:
-  // Min length consists of 4 byte address, 2 byte mem length field, 4 byte data (1 word)
-  static const size_t MIN_COMMAND_DATA_LENGTH = 10;
-  static const size_t MEM_ADDRESS_SIZE = 4;
+  // Min length consists of 4 byte data (1 word)
+  static const size_t MIN_COMMAND_DATA_LENGTH = 1;
   static const size_t FIX_LENGTH = 8;
 
   ReturnValue_t lengthCheck(size_t commandDataLen) {
@@ -305,400 +188,5 @@ class TcMemWrite : public TcBase {
     return HasReturnvaluesIF::RETURN_OK;
   }
 };
-
-/**
- * @brief   Class to help creation of flash fopen command.
- */
-class FlashFopen : public TcBase {
- public:
-  FlashFopen(uint16_t sequenceCount) : TcBase(apid::TC_FLASHFOPEN, sequenceCount) {}
-
-  static const char APPEND = 'a';
-  static const char WRITE = 'w';
-  static const char READ = 'r';
-
-  ReturnValue_t createPacket(std::string filename, char accessMode_) {
-    accessMode = accessMode_;
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    size_t nameSize = filename.size();
-    std::memcpy(this->getPacketData(), filename.c_str(), nameSize);
-    *(this->getPacketData() + nameSize) = NULL_TERMINATOR;
-    std::memcpy(this->getPacketData() + nameSize + sizeof(NULL_TERMINATOR), &accessMode,
-                sizeof(accessMode));
-    this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + sizeof(accessMode) + CRC_SIZE -
-                              1);
-    result = addCrc();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    return result;
-  }
-
- private:
-  char accessMode = APPEND;
-};
-
-/**
- * @brief   Class to help creation of flash fclose command.
- */
-class FlashFclose : public TcBase {
- public:
-  FlashFclose(uint16_t sequenceCount) : TcBase(apid::TC_FLASHFCLOSE, sequenceCount) {}
-
-  ReturnValue_t createPacket(std::string filename) {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    size_t nameSize = filename.size();
-    std::memcpy(this->getPacketData(), filename.c_str(), nameSize);
-    *(this->getPacketData() + nameSize) = NULL_TERMINATOR;
-    this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1);
-    result = addCrc();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    return result;
-  }
-};
-
-/**
- * @brief   Class to build flash write space packet.
- */
-class TcFlashWrite : public TcBase {
- public:
-  TcFlashWrite(uint16_t sequenceCount) : TcBase(apid::TC_FLASHWRITE, sequenceCount) {}
-
-  ReturnValue_t createPacket(const uint8_t* writeData, uint32_t writeLen_) {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    writeLen = writeLen_;
-    if (writeLen > MAX_DATA_SIZE) {
-      sif::debug << "FlashWrite::createPacket: Command data too big" << std::endl;
-      return HasReturnvaluesIF::RETURN_FAILED;
-    }
-    size_t serializedSize = 0;
-    result =
-        SerializeAdapter::serialize<uint32_t>(&writeLen, this->getPacketData(), &serializedSize,
-                                              sizeof(writeLen), SerializeIF::Endianness::BIG);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    std::memcpy(this->getPacketData() + sizeof(writeLen), writeData, writeLen);
-    this->setPacketDataLength(static_cast<uint16_t>(writeLen + CRC_SIZE - 1));
-    result = addCrc();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-
- private:
-  uint32_t writeLen = 0;
-};
-
-/**
- * @brief   Class to help creation of flash delete command.
- */
-class TcFlashDelete : public TcBase {
- public:
-  TcFlashDelete(uint16_t sequenceCount) : TcBase(apid::TC_FLASHDELETE, sequenceCount) {}
-
-  ReturnValue_t createPacket(std::string filename) {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    size_t nameSize = filename.size();
-    std::memcpy(this->getPacketData(), filename.c_str(), nameSize);
-    *(this->getPacketData() + nameSize) = NULL_TERMINATOR;
-    this->setPacketDataLength(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1);
-    result = addCrc();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    return result;
-  }
-};
-
-/**
- * @brief   Class to build replay stop space packet.
- */
-class TcReplayStop : public TcBase {
- public:
-  TcReplayStop(uint16_t sequenceCount) : TcBase(apid::TC_REPLAY_STOP, sequenceCount) {}
-
-  ReturnValue_t createPacket() {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    result = addCrc();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    this->setPacketDataLength(static_cast<uint16_t>(CRC_SIZE - 1));
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-};
-
-/**
- * @brief   This class helps to build the replay start command.
- */
-class TcReplayStart : public TcBase {
- public:
-  /**
-   * @brief   Constructor
-   */
-  TcReplayStart(uint16_t sequenceCount) : TcBase(apid::TC_REPLAY_START, sequenceCount) {}
-
- protected:
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    result = lengthCheck(commandDataLen);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    result = checkData(*commandData);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    std::memcpy(this->localData.fields.buffer, commandData, commandDataLen);
-    this->setPacketDataLength(commandDataLen + CRC_SIZE - 1);
-    return result;
-  }
-
- private:
-  static const size_t COMMAND_DATA_LENGTH = 1;
-  static const uint8_t REPEATING = 0;
-  static const uint8_t ONCE = 1;
-
-  ReturnValue_t lengthCheck(size_t commandDataLen) {
-    if (commandDataLen != COMMAND_DATA_LENGTH) {
-      sif::warning << "TcReplayStart: Command has invalid length " << commandDataLen << std::endl;
-      return INVALID_LENGTH;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-
-  ReturnValue_t checkData(uint8_t replay) {
-    if (replay != REPEATING && replay != ONCE) {
-      sif::warning << "TcReplayStart::checkData: Invalid replay value" << std::endl;
-      return INVALID_PARAMETER;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-};
-
-/**
- * @brief   This class helps to build downlink power on command.
- */
-class TcDownlinkPwrOn : public TcBase {
- public:
-  /**
-   * @brief   Constructor
-   */
-  TcDownlinkPwrOn(uint16_t sequenceCount) : TcBase(apid::TC_DOWNLINK_PWR_ON, sequenceCount) {}
-
- protected:
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    result = lengthCheck(commandDataLen);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    result = modeCheck(*commandData);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    result = laneRateCheck(*(commandData + 1));
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    std::memcpy(this->localData.fields.buffer, commandData, commandDataLen);
-    std::memcpy(this->localData.fields.buffer + commandDataLen, &MAX_AMPLITUDE,
-                sizeof(MAX_AMPLITUDE));
-    this->setPacketDataLength(commandDataLen + sizeof(MAX_AMPLITUDE) + CRC_SIZE - 1);
-    return result;
-  }
-
- private:
-  static const uint8_t INTERFACE_ID = CLASS_ID::DWLPWRON_CMD;
-
-  //! [EXPORT] : [COMMENT] Received command has invalid JESD mode (valid modes are 0 - 5)
-  static const ReturnValue_t INVALID_MODE = MAKE_RETURN_CODE(0xE0);
-  //! [EXPORT] : [COMMENT] Received command has invalid lane rate (valid lane rate are 0 - 9)
-  static const ReturnValue_t INVALID_LANE_RATE = MAKE_RETURN_CODE(0xE1);
-
-  static const size_t COMMAND_DATA_LENGTH = 2;
-  static const uint8_t MAX_MODE = 5;
-  static const uint8_t MAX_LANE_RATE = 9;
-  static const uint16_t MAX_AMPLITUDE = 0;
-
-  ReturnValue_t lengthCheck(size_t commandDataLen) {
-    if (commandDataLen != COMMAND_DATA_LENGTH) {
-      sif::warning << "TcDownlinkPwrOn: Command has invalid length " << commandDataLen << std::endl;
-      return INVALID_LENGTH;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-
-  ReturnValue_t modeCheck(uint8_t mode) {
-    if (mode > MAX_MODE) {
-      sif::warning << "TcDwonlinkPwrOn::modeCheck: Invalid JESD mode" << std::endl;
-      return INVALID_MODE;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-
-  ReturnValue_t laneRateCheck(uint8_t laneRate) {
-    if (laneRate > MAX_LANE_RATE) {
-      sif::warning << "TcReplayStart::laneRateCheck: Invalid lane rate" << std::endl;
-      return INVALID_LANE_RATE;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-};
-
-/**
- * @brief   Class to build replay stop space packet.
- */
-class TcDownlinkPwrOff : public TcBase {
- public:
-  TcDownlinkPwrOff(uint16_t sequenceCount) : TcBase(apid::TC_DOWNLINK_PWR_OFF, sequenceCount) {}
-
-  ReturnValue_t createPacket() {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    result = addCrc();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    this->setPacketDataLength(static_cast<uint16_t>(CRC_SIZE - 1));
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-};
-
-/**
- * @brief   This class helps to build the replay start command.
- */
-class TcReplayWriteSeq : public TcBase {
- public:
-  /**
-   * @brief   Constructor
-   */
-  TcReplayWriteSeq(uint16_t sequenceCount)
-      : TcBase(apid::TC_REPLAY_WRITE_SEQUENCE, sequenceCount) {}
-
- protected:
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    result = lengthCheck(commandDataLen);
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    std::memcpy(this->localData.fields.buffer, commandData, commandDataLen);
-    *(this->localData.fields.buffer + commandDataLen) = NULL_TERMINATOR;
-    this->setPacketDataLength(commandDataLen + sizeof(NULL_TERMINATOR) + CRC_SIZE - 1);
-    return result;
-  }
-
- private:
-  static const size_t USE_DECODING_LENGTH = 1;
-
-  ReturnValue_t lengthCheck(size_t commandDataLen) {
-    if (commandDataLen > USE_DECODING_LENGTH + MAX_FILENAME_SIZE) {
-      sif::warning << "TcReplayWriteSeq: Command has invalid length " << commandDataLen
-                   << std::endl;
-      return INVALID_LENGTH;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-};
-
-/**
- * @brief   Helps to extract the fields of the flash write command from the PUS packet.
- */
-class FlashWritePusCmd : public MPSoCReturnValuesIF {
- public:
-  FlashWritePusCmd(){};
-
-  ReturnValue_t extractFields(const uint8_t* commandData, size_t commandDataLen) {
-    if (commandDataLen > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE + MAX_FILENAME_SIZE)) {
-      return INVALID_LENGTH;
-    }
-    obcFile = std::string(reinterpret_cast<const char*>(commandData));
-    if (obcFile.size() > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE)) {
-      return FILENAME_TOO_LONG;
-    }
-    mpsocFile = std::string(
-        reinterpret_cast<const char*>(commandData + obcFile.size() + SIZE_NULL_TERMINATOR));
-    if (mpsocFile.size() > MAX_FILENAME_SIZE) {
-      return MPSOC_FILENAME_TOO_LONG;
-    }
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-
-  std::string getObcFile() { return obcFile; }
-
-  std::string getMPSoCFile() { return mpsocFile; }
-
- private:
-  static const size_t SIZE_NULL_TERMINATOR = 1;
-  std::string obcFile = "";
-  std::string mpsocFile = "";
-};
-
-/**
- * @brief   Class to build replay stop space packet.
- */
-class TcModeReplay : public TcBase {
- public:
-  TcModeReplay(uint16_t sequenceCount) : TcBase(apid::TC_MODE_REPLAY, sequenceCount) {}
-
-  ReturnValue_t createPacket() {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    result = addCrc();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    this->setPacketDataLength(static_cast<uint16_t>(CRC_SIZE - 1));
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-};
-
-/**
- * @brief   Class to build mode idle command
- */
-class TcModeIdle : public TcBase {
- public:
-  TcModeIdle(uint16_t sequenceCount) : TcBase(apid::TC_MODE_IDLE, sequenceCount) {}
-
-  ReturnValue_t createPacket() {
-    ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-    result = addCrc();
-    if (result != HasReturnvaluesIF::RETURN_OK) {
-      return result;
-    }
-    this->setPacketDataLength(static_cast<uint16_t>(CRC_SIZE - 1));
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-};
-
-class TcCamcmdSend : public TcBase {
- public:
-  TcCamcmdSend(uint16_t sequenceCount) : TcBase(apid::TC_CAM_CMD_SEND, sequenceCount) {}
-
- protected:
-  ReturnValue_t initPacket(const uint8_t* commandData, size_t commandDataLen) {
-    if (commandDataLen > MAX_DATA_LENGTH) {
-      return INVALID_LENGTH;
-    }
-    uint16_t dataLen = static_cast<uint16_t>(commandDataLen + sizeof(CARRIAGE_RETURN));
-    size_t size = sizeof(dataLen);
-    SerializeAdapter::serialize(&dataLen, this->getPacketData(), &size, sizeof(dataLen),
-                                SerializeIF::Endianness::BIG);
-    std::memcpy(this->getPacketData() + sizeof(dataLen), commandData, commandDataLen);
-    *(this->getPacketData() + sizeof(dataLen) + commandDataLen) = CARRIAGE_RETURN;
-    uint16_t trueLength = sizeof(dataLen) + commandDataLen + sizeof(CARRIAGE_RETURN) + CRC_SIZE;
-    this->setPacketDataLength(trueLength - 1);
-    return HasReturnvaluesIF::RETURN_OK;
-  }
-
- private:
-  static const uint8_t MAX_DATA_LENGTH = 10;
-  static const uint8_t CARRIAGE_RETURN = 0xD;
-};
-
 }  // namespace mpsoc
-
 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_PLOCMPSOCDEFINITIONS_H_ */

linux/devices/devicedefinitions/PlocMemDumpActions.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <fsfw/action/MinMaxParameter.h>
+#include <fsfw/action/TemplateAction.h>
+#include <fsfw/introspection/Enum.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+
+class PlocMemoryDumper;
+
+FSFW_ENUM(PlocMemoryDumperCommands, DeviceCommandId_t,
+          ((DUMP_MRAM, 1 ,"Dump Memory")))
+
+class DumpMemoryAction : public TemplateAction<PlocMemoryDumper, DumpMemoryAction, PlocMemoryDumperCommands> {
+    public:
+    DumpMemoryAction(PlocMemoryDumper * owner): TemplateAction(owner, PlocMemoryDumperCommands::DUMP_MRAM) {}
+
+    //Memory is 512KiB
+    MinMaxParameter<uint32_t> startAddress = MinMaxParameter<uint32_t>::createMinMaxParameter(this, "Start Address", 0 , 0x80000);
+    MinMaxParameter<uint32_t> endAddress = MinMaxParameter<uint32_t>::createMinMaxParameter(this, "End Address", 0 , 0x80000);
+};

linux/devices/ploc/PlocMPSoCHandler.cpp

@@ -5,6 +5,8 @@
 #include "fsfw/globalfunctions/CRC.h"
 #include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"
 
+// TODO this is work in progress in adapting to new actions
+
 PlocMPSoCHandler::PlocMPSoCHandler(object_id_t objectId, object_id_t uartComIFid,
                                    CookieIF* comCookie, PlocMPSoCHelper* plocMPSoCHelper,
                                    Gpio uartIsolatorSwitch, object_id_t supervisorHandler)
@@ -96,16 +98,14 @@ void PlocMPSoCHandler::performOperationHook() {
   }
 }
 
-ReturnValue_t PlocMPSoCHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                              const uint8_t* data, size_t size) {
-  ReturnValue_t result = RETURN_OK;
-  switch (actionId) {
-    case mpsoc::SET_UART_TX_TRISTATE: {
+ReturnValue_t PlocMPSoCHandler::executeAction(Action* action) {
+  switch (PlocMpSoCCommands(action->getId())) {
+    case PlocMpSoCCommands::SET_UART_TX_TRISTATE: {
       uartIsolatorSwitch.pullLow();
       return EXECUTION_FINISHED;
       break;
     }
-    case mpsoc::RELEASE_UART_TX: {
+    case PlocMpSoCCommands::RELEASE_UART_TX: {
       uartIsolatorSwitch.pullHigh();
       return EXECUTION_FINISHED;
       break;
@@ -118,32 +118,28 @@ ReturnValue_t PlocMPSoCHandler::executeAction(ActionId_t actionId, MessageQueueI
     return MPSoCReturnValuesIF::MPSOC_HELPER_EXECUTING;
   }
 
-  switch (actionId) {
-    case mpsoc::TC_FLASHWRITE: {
-      if (size > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
-        return MPSoCReturnValuesIF::FILENAME_TOO_LONG;
-      }
-      mpsoc::FlashWritePusCmd flashWritePusCmd;
-      result = flashWritePusCmd.extractFields(data, size);
-      if (result != RETURN_OK) {
-        return result;
-      }
-      result = plocMPSoCHelper->startFlashWrite(flashWritePusCmd.getObcFile(),
-                                                flashWritePusCmd.getMPSoCFile());
-      if (result != RETURN_OK) {
-        return result;
-      }
-      plocMPSoCHelperExecuting = true;
-      return EXECUTION_FINISHED;
+  switch (PlocMpSoCCommands(action->getId())) {
+    case PlocMpSoCCommands::TC_FLASHWRITE: {
+      // refer handling to the handleAction() below
+      return action->handle();
     }
-    case (mpsoc::OBSW_RESET_SEQ_COUNT): {
+    case (PlocMpSoCCommands::OBSW_RESET_SEQ_COUNT): {
       sequenceCount = 0;
       return EXECUTION_FINISHED;
     }
     default:
       break;
   }
-  return DeviceHandlerBase::executeAction(actionId, commandedBy, data, size);
+  ReturnValue_t result = DeviceHandlerBase::executeAction(action);
+
+  if (result == RETURN_OK) {
+    /**
+     * Flushing the receive buffer to make sure there are no data left from a faulty reply.
+     */
+    uartComIf->flushUartRxBuffer(comCookie);
+  }
+
+  return result;
 }
 
 void PlocMPSoCHandler::doStartUp() {
@@ -203,90 +199,29 @@ ReturnValue_t PlocMPSoCHandler::buildTransitionDeviceCommand(DeviceCommandId_t*
   return NOTHING_TO_SEND;
 }
 
-ReturnValue_t PlocMPSoCHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                        const uint8_t* commandData,
-                                                        size_t commandDataLen) {
-  ReturnValue_t result = RETURN_OK;
-  switch (deviceCommand) {
-    case (mpsoc::TC_MEM_WRITE): {
-      result = prepareTcMemWrite(commandData, commandDataLen);
-      break;
-    }
-    case (mpsoc::TC_MEM_READ): {
-      result = prepareTcMemRead(commandData, commandDataLen);
-      break;
-    }
-    case (mpsoc::TC_FLASHDELETE): {
-      result = prepareTcFlashDelete(commandData, commandDataLen);
-      break;
-    }
-    case (mpsoc::TC_REPLAY_START): {
-      result = prepareTcReplayStart(commandData, commandDataLen);
-      break;
-    }
-    case (mpsoc::TC_REPLAY_STOP): {
-      result = prepareTcReplayStop();
-      break;
-    }
-    case (mpsoc::TC_DOWNLINK_PWR_ON): {
-      result = prepareTcDownlinkPwrOn(commandData, commandDataLen);
-      break;
-    }
-    case (mpsoc::TC_DOWNLINK_PWR_OFF): {
-      result = prepareTcDownlinkPwrOff();
-      break;
-    }
-    case (mpsoc::TC_REPLAY_WRITE_SEQUENCE): {
-      result = prepareTcReplayWriteSequence(commandData, commandDataLen);
-      break;
-    }
-    case (mpsoc::TC_MODE_REPLAY): {
-      result = prepareTcModeReplay();
-      break;
-    }
-    case (mpsoc::TC_MODE_IDLE): {
-      result = prepareTcModeIdle();
-      break;
-    }
-    case (mpsoc::TC_CAM_CMD_SEND): {
-      result = prepareTcCamCmdSend(commandData, commandDataLen);
-      break;
-    }
-    default:
-      sif::debug << "PlocMPSoCHandler::buildCommandFromCommand: Command not implemented"
-                 << std::endl;
-      result = DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
-      break;
-  }
-
-  if (result == RETURN_OK) {
-    /**
-     * Flushing the receive buffer to make sure there are no data left from a faulty reply.
-     */
-    uartComIf->flushUartRxBuffer(comCookie);
-  }
-
-  return result;
-}
-
 void PlocMPSoCHandler::fillCommandAndReplyMap() {
-  this->insertInCommandMap(mpsoc::TC_MEM_WRITE);
-  this->insertInCommandMap(mpsoc::TC_MEM_READ);
-  this->insertInCommandMap(mpsoc::TC_FLASHDELETE);
-  this->insertInCommandMap(mpsoc::TC_REPLAY_START);
-  this->insertInCommandMap(mpsoc::TC_REPLAY_STOP);
-  this->insertInCommandMap(mpsoc::TC_DOWNLINK_PWR_ON);
-  this->insertInCommandMap(mpsoc::TC_DOWNLINK_PWR_OFF);
-  this->insertInCommandMap(mpsoc::TC_REPLAY_WRITE_SEQUENCE);
-  this->insertInCommandMap(mpsoc::TC_MODE_REPLAY);
-  this->insertInCommandMap(mpsoc::TC_MODE_IDLE);
-  this->insertInCommandMap(mpsoc::TC_CAM_CMD_SEND);
-  this->insertInCommandMap(mpsoc::RELEASE_UART_TX);
-  this->insertInCommandMap(mpsoc::SET_UART_TX_TRISTATE);
-  this->insertInReplyMap(mpsoc::ACK_REPORT, 3, nullptr, mpsoc::SIZE_ACK_REPORT);
-  this->insertInReplyMap(mpsoc::EXE_REPORT, 3, nullptr, mpsoc::SIZE_EXE_REPORT);
-  this->insertInReplyMap(mpsoc::TM_MEMORY_READ_REPORT, 2, nullptr, mpsoc::SIZE_TM_MEM_READ_REPORT);
-  this->insertInReplyMap(mpsoc::TM_CAM_CMD_RPT, 2, nullptr, SpacePacket::PACKET_MAX_SIZE);
+  this->insertInCommandMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TC_MEM_WRITE));
+  this->insertInCommandMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TC_MEM_READ));
+  this->insertInCommandMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TC_FLASHDELETE));
+  this->insertInCommandMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TC_REPLAY_START));
+  this->insertInCommandMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TC_REPLAY_STOP));
+  this->insertInCommandMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TC_DOWNLINK_PWR_ON));
+  this->insertInCommandMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TC_DOWNLINK_PWR_OFF));
+  this->insertInCommandMap(
+      static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TC_REPLAY_WRITE_SEQUENCE));
+  this->insertInCommandMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TC_MODE_REPLAY));
+  this->insertInCommandMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TC_MODE_IDLE));
+  this->insertInCommandMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TC_CAM_CMD_SEND));
+  this->insertInCommandMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::RELEASE_UART_TX));
+  this->insertInCommandMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::SET_UART_TX_TRISTATE));
+  this->insertInReplyMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::ACK_REPORT), 3, nullptr,
+                         mpsoc::SIZE_ACK_REPORT);
+  this->insertInReplyMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::EXE_REPORT), 3, nullptr,
+                         mpsoc::SIZE_EXE_REPORT);
+  this->insertInReplyMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TM_MEMORY_READ_REPORT),
+                         2, nullptr, mpsoc::SIZE_TM_MEM_READ_REPORT);
+  this->insertInReplyMap(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TM_CAM_CMD_RPT), 2,
+                         nullptr, SpacePacket::PACKET_MAX_SIZE);
 }
 
 ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remainingSize,
@@ -300,28 +235,28 @@ ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remain
   switch (apid) {
     case (mpsoc::apid::ACK_SUCCESS):
       *foundLen = mpsoc::SIZE_ACK_REPORT;
-      *foundId = mpsoc::ACK_REPORT;
+      *foundId = static_cast<DeviceCommandId_t>(PlocMpSoCCommands::ACK_REPORT);
       break;
     case (mpsoc::apid::ACK_FAILURE):
       *foundLen = mpsoc::SIZE_ACK_REPORT;
-      *foundId = mpsoc::ACK_REPORT;
+      *foundId = static_cast<DeviceCommandId_t>(PlocMpSoCCommands::ACK_REPORT);
       break;
     case (mpsoc::apid::TM_MEMORY_READ_REPORT):
       *foundLen = tmMemReadReport.rememberRequestedSize;
-      *foundId = mpsoc::TM_MEMORY_READ_REPORT;
+      *foundId = static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TM_MEMORY_READ_REPORT);
       break;
     case (mpsoc::apid::TM_CAM_CMD_RPT):
       *foundLen = spacePacket.getFullSize();
       tmCamCmdRpt.rememberSpacePacketSize = *foundLen;
-      *foundId = mpsoc::TM_CAM_CMD_RPT;
+      *foundId = static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TM_CAM_CMD_RPT);
       break;
     case (mpsoc::apid::EXE_SUCCESS):
       *foundLen = mpsoc::SIZE_EXE_REPORT;
-      *foundId = mpsoc::EXE_REPORT;
+      *foundId = static_cast<DeviceCommandId_t>(PlocMpSoCCommands::EXE_REPORT);
       break;
     case (mpsoc::apid::EXE_FAILURE):
       *foundLen = mpsoc::SIZE_EXE_REPORT;
-      *foundId = mpsoc::EXE_REPORT;
+      *foundId = static_cast<DeviceCommandId_t>(PlocMpSoCCommands::EXE_REPORT);
       break;
     default: {
       sif::debug << "PlocMPSoCHandler::scanForReply: Reply has invalid apid" << std::endl;
@@ -342,20 +277,22 @@ ReturnValue_t PlocMPSoCHandler::scanForReply(const uint8_t* start, size_t remain
 ReturnValue_t PlocMPSoCHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) {
   ReturnValue_t result = RETURN_OK;
 
-  switch (id) {
-    case mpsoc::ACK_REPORT: {
+  PlocMpSoCCommands enumId = PlocMpSoCCommands(id);
+
+  switch (enumId) {
+    case PlocMpSoCCommands::ACK_REPORT: {
       result = handleAckReport(packet);
       break;
     }
-    case (mpsoc::TM_MEMORY_READ_REPORT): {
+    case (PlocMpSoCCommands::TM_MEMORY_READ_REPORT): {
       result = handleMemoryReadReport(packet);
       break;
     }
-    case (mpsoc::TM_CAM_CMD_RPT): {
+    case (PlocMpSoCCommands::TM_CAM_CMD_RPT): {
       result = handleCamCmdRpt(packet);
       break;
     }
-    case (mpsoc::EXE_REPORT): {
+    case (PlocMpSoCCommands::EXE_REPORT): {
       result = handleExecutionReport(packet);
       break;
     }
@@ -390,12 +327,17 @@ void PlocMPSoCHandler::handleEvent(EventMessage* eventMessage) {
   }
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcMemWrite(const uint8_t* commandData,
-                                                  size_t commandDataLen) {
+ReturnValue_t PlocMPSoCHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                        const uint8_t* commandData,
+                                                        size_t commandDataLen) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCMemWriteAction* action) {
   ReturnValue_t result = RETURN_OK;
   sequenceCount++;
   mpsoc::TcMemWrite tcMemWrite(sequenceCount);
-  result = tcMemWrite.createPacket(commandData, commandDataLen);
+  result = tcMemWrite.createPacket(action);
   if (result != RETURN_OK) {
     sequenceCount--;
     return result;
@@ -403,13 +345,11 @@ ReturnValue_t PlocMPSoCHandler::prepareTcMemWrite(const uint8_t* commandData,
   copyToCommandBuffer(&tcMemWrite);
   return RETURN_OK;
 }
-
-ReturnValue_t PlocMPSoCHandler::prepareTcMemRead(const uint8_t* commandData,
-                                                 size_t commandDataLen) {
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCMemReadAction* action) {
   ReturnValue_t result = RETURN_OK;
   sequenceCount++;
   mpsoc::TcMemRead tcMemRead(sequenceCount);
-  result = tcMemRead.createPacket(commandData, commandDataLen);
+  // result = tcMemRead.createPacket(commandData, commandDataLen);
   if (result != RETURN_OK) {
     sequenceCount--;
     return result;
@@ -418,17 +358,15 @@ ReturnValue_t PlocMPSoCHandler::prepareTcMemRead(const uint8_t* commandData,
   tmMemReadReport.rememberRequestedSize = tcMemRead.getMemLen() * 4 + TmMemReadReport::FIX_SIZE;
   return RETURN_OK;
 }
-
-ReturnValue_t PlocMPSoCHandler::prepareTcFlashDelete(const uint8_t* commandData,
-                                                     size_t commandDataLen) {
-  if (commandDataLen > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
-    return MPSoCReturnValuesIF::NAME_TOO_LONG;
-  }
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCFlashDeleteAction* action) {
+  // if (commandDataLen > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
+  //   return MPSoCReturnValuesIF::NAME_TOO_LONG;
+  // }
   ReturnValue_t result = RETURN_OK;
   sequenceCount++;
   mpsoc::TcFlashDelete tcFlashDelete(sequenceCount);
-  result = tcFlashDelete.createPacket(
-      std::string(reinterpret_cast<const char*>(commandData), commandDataLen));
+  // result = tcFlashDelete.createPacket(
+  //     std::string(reinterpret_cast<const char*>(commandData), commandDataLen));
   if (result != RETURN_OK) {
     sequenceCount--;
     return result;
@@ -436,13 +374,11 @@ ReturnValue_t PlocMPSoCHandler::prepareTcFlashDelete(const uint8_t* commandData,
   copyToCommandBuffer(&tcFlashDelete);
   return RETURN_OK;
 }
-
-ReturnValue_t PlocMPSoCHandler::prepareTcReplayStart(const uint8_t* commandData,
-                                                     size_t commandDataLen) {
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCReplayStartAction* action) {
   ReturnValue_t result = RETURN_OK;
   sequenceCount++;
   mpsoc::TcReplayStart tcReplayStart(sequenceCount);
-  result = tcReplayStart.createPacket(commandData, commandDataLen);
+  // result = tcReplayStart.createPacket(commandData, commandDataLen);
   if (result != RETURN_OK) {
     sequenceCount--;
     return result;
@@ -450,8 +386,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcReplayStart(const uint8_t* commandData,
   copyToCommandBuffer(&tcReplayStart);
   return RETURN_OK;
 }
-
-ReturnValue_t PlocMPSoCHandler::prepareTcReplayStop() {
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCReplayStopAction* action) {
   ReturnValue_t result = RETURN_OK;
   sequenceCount++;
   mpsoc::TcReplayStop tcReplayStop(sequenceCount);
@@ -464,12 +399,11 @@ ReturnValue_t PlocMPSoCHandler::prepareTcReplayStop() {
   return RETURN_OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOn(const uint8_t* commandData,
-                                                       size_t commandDataLen) {
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCDownlinkPwrOnAction* action) {
   ReturnValue_t result = RETURN_OK;
   sequenceCount++;
   mpsoc::TcDownlinkPwrOn tcDownlinkPwrOn(sequenceCount);
-  result = tcDownlinkPwrOn.createPacket(commandData, commandDataLen);
+  // result = tcDownlinkPwrOn.createPacket(commandData, commandDataLen);
   if (result != RETURN_OK) {
     sequenceCount--;
     return result;
@@ -477,8 +411,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOn(const uint8_t* commandDat
   copyToCommandBuffer(&tcDownlinkPwrOn);
   return RETURN_OK;
 }
-
-ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOff() {
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCDownlinkPwrOffAction* action) {
   ReturnValue_t result = RETURN_OK;
   sequenceCount++;
   mpsoc::TcDownlinkPwrOff tcDownlinkPwrOff(sequenceCount);
@@ -491,12 +424,11 @@ ReturnValue_t PlocMPSoCHandler::prepareTcDownlinkPwrOff() {
   return RETURN_OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* commandData,
-                                                             size_t commandDataLen) {
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCReplayWriteSequenceAction* action) {
   ReturnValue_t result = RETURN_OK;
   sequenceCount++;
   mpsoc::TcReplayWriteSeq tcReplayWriteSeq(sequenceCount);
-  result = tcReplayWriteSeq.createPacket(commandData, commandDataLen);
+  // result = tcReplayWriteSeq.createPacket(commandData, commandDataLen);
   if (result != RETURN_OK) {
     sequenceCount--;
     return result;
@@ -505,7 +437,7 @@ ReturnValue_t PlocMPSoCHandler::prepareTcReplayWriteSequence(const uint8_t* comm
   return RETURN_OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcModeReplay() {
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCModeReplayAction* action) {
   ReturnValue_t result = RETURN_OK;
   sequenceCount++;
   mpsoc::TcModeReplay tcModeReplay(sequenceCount);
@@ -517,11 +449,11 @@ ReturnValue_t PlocMPSoCHandler::prepareTcModeReplay() {
   memcpy(commandBuffer, tcModeReplay.getWholeData(), tcModeReplay.getFullSize());
   rawPacket = commandBuffer;
   rawPacketLen = tcModeReplay.getFullSize();
-  nextReplyId = mpsoc::ACK_REPORT;
+  nextReplyId = PlocMpSoCCommands::ACK_REPORT;
   return RETURN_OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcModeIdle() {
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCModeIdleAction* action) {
   ReturnValue_t result = RETURN_OK;
   sequenceCount++;
   mpsoc::TcModeIdle tcModeIdle(sequenceCount);
@@ -533,22 +465,52 @@ ReturnValue_t PlocMPSoCHandler::prepareTcModeIdle() {
   memcpy(commandBuffer, tcModeIdle.getWholeData(), tcModeIdle.getFullSize());
   rawPacket = commandBuffer;
   rawPacketLen = tcModeIdle.getFullSize();
-  nextReplyId = mpsoc::ACK_REPORT;
+  nextReplyId = PlocMpSoCCommands::ACK_REPORT;
   return RETURN_OK;
 }
 
-ReturnValue_t PlocMPSoCHandler::prepareTcCamCmdSend(const uint8_t* commandData,
-                                                    size_t commandDataLen) {
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCCamCmdSendAction* action) {
   ReturnValue_t result = RETURN_OK;
   sequenceCount++;
   mpsoc::TcCamcmdSend tcCamCmdSend(sequenceCount);
-  result = tcCamCmdSend.createPacket(commandData, commandDataLen);
+  // result = tcCamCmdSend.createPacket(commandData, commandDataLen);
   if (result != RETURN_OK) {
     sequenceCount--;
     return result;
   }
   copyToCommandBuffer(&tcCamCmdSend);
-  nextReplyId = mpsoc::TM_CAM_CMD_RPT;
+  nextReplyId = PlocMpSoCCommands::TM_CAM_CMD_RPT;
+  return RETURN_OK;
+}
+
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCFlashWriteAction* action) {
+  ReturnValue_t result = RETURN_OK;
+  // if (size > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
+  //   return MPSoCReturnValuesIF::FILENAME_TOO_LONG;
+  // }
+  mpsoc::FlashWritePusCmd flashWritePusCmd;
+  // result = flashWritePusCmd.extractFields(data, size);
+  if (result != RETURN_OK) {
+    return result;
+  }
+  result = plocMPSoCHelper->startFlashWrite(flashWritePusCmd.getObcFile(),
+                                            flashWritePusCmd.getMPSoCFile());
+  if (result != RETURN_OK) {
+    return result;
+  }
+  plocMPSoCHelperExecuting = true;
+  return EXECUTION_FINISHED;
+}
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCUartTxTristateAction* action) {
+  // not used
+  return RETURN_OK;
+}
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCReleaseUartTxAction* action) {
+  // not used
+  return RETURN_OK;
+}
+ReturnValue_t PlocMPSoCHandler::handleAction(PlocMpSoCObswResetSeqCountAction* action) {
+  // not used
   return RETURN_OK;
 }
 
@@ -559,7 +521,7 @@ void PlocMPSoCHandler::copyToCommandBuffer(mpsoc::TcBase* tc) {
   memcpy(commandBuffer, tc->getWholeData(), tc->getFullSize());
   rawPacket = commandBuffer;
   rawPacketLen = tc->getFullSize();
-  nextReplyId = mpsoc::ACK_REPORT;
+  nextReplyId = PlocMpSoCCommands::ACK_REPORT;
 }
 
 ReturnValue_t PlocMPSoCHandler::verifyPacket(const uint8_t* start, size_t foundLen) {
@@ -577,10 +539,10 @@ ReturnValue_t PlocMPSoCHandler::handleAckReport(const uint8_t* data) {
   result = verifyPacket(data, mpsoc::SIZE_ACK_REPORT);
   if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
     sif::warning << "PlocMPSoCHandler::handleAckReport: CRC failure" << std::endl;
-    nextReplyId = mpsoc::NONE;
+    nextReplyId = PlocMpSoCCommands::NONE;
     replyRawReplyIfnotWiretapped(data, mpsoc::SIZE_ACK_REPORT);
     triggerEvent(MPSOC_HANDLER_CRC_FAILURE);
-    sendFailureReport(mpsoc::ACK_REPORT, MPSoCReturnValuesIF::CRC_FAILURE);
+    sendFailureReport(PlocMpSoCCommands::ACK_REPORT, MPSoCReturnValuesIF::CRC_FAILURE);
     disableAllReplies();
     return IGNORE_REPLY_DATA;
   }
@@ -596,9 +558,9 @@ ReturnValue_t PlocMPSoCHandler::handleAckReport(const uint8_t* data) {
       if (commandId != DeviceHandlerIF::NO_COMMAND_ID) {
         triggerEvent(ACK_FAILURE, commandId, status);
       }
-      sendFailureReport(mpsoc::ACK_REPORT, status);
+      sendFailureReport(PlocMpSoCCommands::ACK_REPORT, status);
       disableAllReplies();
-      nextReplyId = mpsoc::NONE;
+      nextReplyId = PlocMpSoCCommands::NONE;
       result = IGNORE_REPLY_DATA;
       break;
     }
@@ -622,7 +584,7 @@ ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) {
   result = verifyPacket(data, mpsoc::SIZE_EXE_REPORT);
   if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
     sif::warning << "PlocMPSoCHandler::handleExecutionReport: CRC failure" << std::endl;
-    nextReplyId = mpsoc::NONE;
+    nextReplyId = PlocMpSoCCommands::NONE;
     return result;
   }
 
@@ -644,7 +606,7 @@ ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) {
         sif::debug << "PlocMPSoCHandler::handleExecutionReport: Unknown command id" << std::endl;
       }
       printStatus(data);
-      sendFailureReport(mpsoc::EXE_REPORT, MPSoCReturnValuesIF::RECEIVED_EXE_FAILURE);
+      sendFailureReport(PlocMpSoCCommands::EXE_REPORT, MPSoCReturnValuesIF::RECEIVED_EXE_FAILURE);
       disableExeReportReply();
       result = IGNORE_REPLY_DATA;
       break;
@@ -655,7 +617,7 @@ ReturnValue_t PlocMPSoCHandler::handleExecutionReport(const uint8_t* data) {
       break;
     }
   }
-  nextReplyId = mpsoc::NONE;
+  nextReplyId = PlocMpSoCCommands::NONE;
   return result;
 }
 
@@ -670,8 +632,8 @@ ReturnValue_t PlocMPSoCHandler::handleMemoryReadReport(const uint8_t* data) {
       *(data + mpsoc::MEM_READ_RPT_LEN_OFFSET) << 8 | *(data + mpsoc::MEM_READ_RPT_LEN_OFFSET + 1);
   /** Send data to commanding queue */
   handleDeviceTM(data + mpsoc::DATA_FIELD_OFFSET, mpsoc::SIZE_MEM_READ_RPT_FIX + memLen * 4,
-                 mpsoc::TM_MEMORY_READ_REPORT);
-  nextReplyId = mpsoc::EXE_REPORT;
+                 static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TM_MEMORY_READ_REPORT));
+  nextReplyId = PlocMpSoCCommands::EXE_REPORT;
   return result;
 }
 
@@ -694,7 +656,7 @@ ReturnValue_t PlocMPSoCHandler::handleCamCmdRpt(const uint8_t* data) {
             << static_cast<unsigned int>(ackValue) << std::endl;
 #endif /* OBSW_DEBUG_PLOC_MPSOC == 1 */
   handleDeviceTM(packet.getPacketData() + sizeof(uint16_t), packet.getPacketDataLength() - 1,
-                 mpsoc::TM_CAM_CMD_RPT);
+                 static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TM_CAM_CMD_RPT));
   return result;
 }
 
@@ -705,41 +667,47 @@ ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator
 
   uint8_t enabledReplies = 0;
 
-  switch (command->first) {
-    case mpsoc::TC_MEM_WRITE:
-    case mpsoc::TC_FLASHDELETE:
-    case mpsoc::TC_REPLAY_START:
-    case mpsoc::TC_REPLAY_STOP:
-    case mpsoc::TC_DOWNLINK_PWR_ON:
-    case mpsoc::TC_DOWNLINK_PWR_OFF:
-    case mpsoc::TC_REPLAY_WRITE_SEQUENCE:
-    case mpsoc::TC_MODE_REPLAY:
-    case mpsoc::TC_MODE_IDLE:
+  PlocMpSoCCommands enumCommand = PlocMpSoCCommands(command->first);
+
+  switch (enumCommand) {
+    case PlocMpSoCCommands::TC_MEM_WRITE:
+    case PlocMpSoCCommands::TC_FLASHDELETE:
+    case PlocMpSoCCommands::TC_REPLAY_START:
+    case PlocMpSoCCommands::TC_REPLAY_STOP:
+    case PlocMpSoCCommands::TC_DOWNLINK_PWR_ON:
+    case PlocMpSoCCommands::TC_DOWNLINK_PWR_OFF:
+    case PlocMpSoCCommands::TC_REPLAY_WRITE_SEQUENCE:
+    case PlocMpSoCCommands::TC_MODE_REPLAY:
+    case PlocMpSoCCommands::TC_MODE_IDLE:
       enabledReplies = 2;
       break;
-    case mpsoc::TC_MEM_READ: {
+    case PlocMpSoCCommands::TC_MEM_READ: {
       enabledReplies = 3;
-      result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
-                                                        mpsoc::TM_MEMORY_READ_REPORT);
+      result = DeviceHandlerBase::enableReplyInReplyMap(
+          command, enabledReplies, true,
+          static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TM_MEMORY_READ_REPORT));
       if (result != RETURN_OK) {
         sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id "
-                   << mpsoc::TM_MEMORY_READ_REPORT << " not in replyMap" << std::endl;
+                   << static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TM_MEMORY_READ_REPORT)
+                   << " not in replyMap" << std::endl;
         return result;
       }
       break;
     }
-    case mpsoc::TC_CAM_CMD_SEND: {
+    case PlocMpSoCCommands::TC_CAM_CMD_SEND: {
       enabledReplies = 3;
-      result = DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true,
-                                                        mpsoc::TM_CAM_CMD_RPT);
+      result = DeviceHandlerBase::enableReplyInReplyMap(
+          command, enabledReplies, true,
+          static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TM_CAM_CMD_RPT));
       if (result != RETURN_OK) {
         sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id "
-                   << mpsoc::TM_CAM_CMD_RPT << " not in replyMap" << std::endl;
+                   << static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TM_CAM_CMD_RPT)
+                   << " not in replyMap" << std::endl;
         return result;
       }
       break;
     }
-    case mpsoc::OBSW_RESET_SEQ_COUNT:
+    case PlocMpSoCCommands::OBSW_RESET_SEQ_COUNT:
       break;
     default:
       sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Unknown command id" << std::endl;
@@ -750,32 +718,36 @@ ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator
    * Every command causes at least one acknowledgment and one execution report. Therefore both
    * replies will be enabled here.
    */
-  result =
-      DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, mpsoc::ACK_REPORT);
+  result = DeviceHandlerBase::enableReplyInReplyMap(
+      command, enabledReplies, true, static_cast<DeviceCommandId_t>(PlocMpSoCCommands::ACK_REPORT));
   if (result != RETURN_OK) {
-    sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id " << mpsoc::ACK_REPORT
+    sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id "
+               << static_cast<DeviceCommandId_t>(PlocMpSoCCommands::ACK_REPORT)
                << " not in replyMap" << std::endl;
   }
 
-  result =
-      DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, mpsoc::EXE_REPORT);
+  result = DeviceHandlerBase::enableReplyInReplyMap(
+      command, enabledReplies, true, static_cast<DeviceCommandId_t>(PlocMpSoCCommands::EXE_REPORT));
   if (result != RETURN_OK) {
-    sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id " << mpsoc::EXE_REPORT
+    sif::debug << "PlocMPSoCHandler::enableReplyInReplyMap: Reply with id "
+               << static_cast<DeviceCommandId_t>(PlocMpSoCCommands::EXE_REPORT)
                << " not in replyMap" << std::endl;
   }
 
-  switch (command->first) {
-    case mpsoc::TC_REPLAY_WRITE_SEQUENCE: {
-      DeviceReplyIter iter = deviceReplyMap.find(mpsoc::EXE_REPORT);
+  switch (enumCommand) {
+    case PlocMpSoCCommands::TC_REPLAY_WRITE_SEQUENCE: {
+      DeviceReplyIter iter =
+          deviceReplyMap.find(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::EXE_REPORT));
       // Overwrite delay cycles because replay write sequence command can required up to
       // 30 seconds for execution
       iter->second.delayCycles = mpsoc::TC_WRITE_SEQ_EXECUTION_DELAY;
       break;
     }
-    case mpsoc::TC_DOWNLINK_PWR_ON: {
-      DeviceReplyIter iter = deviceReplyMap.find(mpsoc::EXE_REPORT);
+    case PlocMpSoCCommands::TC_DOWNLINK_PWR_ON: {
+      DeviceReplyIter iter =
+          deviceReplyMap.find(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::EXE_REPORT));
       //
-      iter->second.delayCycles = mpsoc::TC_DOWNLINK_PWR_ON;
+      iter->second.delayCycles = mpsoc::TC_DOWNLINK_PWR_ON_EXECUTION_DELAY;
       break;
     }
     default:
@@ -786,24 +758,24 @@ ReturnValue_t PlocMPSoCHandler::enableReplyInReplyMap(DeviceCommandMap::iterator
 }
 
 void PlocMPSoCHandler::setNextReplyId() {
-  switch (getPendingCommand()) {
-    case mpsoc::TC_MEM_READ:
-      nextReplyId = mpsoc::TM_MEMORY_READ_REPORT;
+  switch (PlocMpSoCCommands(getPendingCommand())) {
+    case PlocMpSoCCommands::TC_MEM_READ:
+      nextReplyId = PlocMpSoCCommands::TM_MEMORY_READ_REPORT;
       break;
     default:
       /* If no telemetry is expected the next reply is always the execution report */
-      nextReplyId = mpsoc::EXE_REPORT;
+      nextReplyId = PlocMpSoCCommands::EXE_REPORT;
       break;
   }
 }
 size_t PlocMPSoCHandler::getNextReplyLength(DeviceCommandId_t commandId) {
   size_t replyLen = 0;
 
-  if (nextReplyId == mpsoc::NONE) {
+  if (nextReplyId == PlocMpSoCCommands::NONE) {
     return replyLen;
   }
 
-  DeviceReplyIter iter = deviceReplyMap.find(nextReplyId);
+  DeviceReplyIter iter = deviceReplyMap.find(static_cast<DeviceCommandId_t>(nextReplyId));
 
   if (iter != deviceReplyMap.end()) {
     if (iter->second.delayCycles == 0) {
@@ -811,11 +783,11 @@ size_t PlocMPSoCHandler::getNextReplyLength(DeviceCommandId_t commandId) {
       return replyLen;
     }
     switch (nextReplyId) {
-      case mpsoc::TM_MEMORY_READ_REPORT: {
+      case PlocMpSoCCommands::TM_MEMORY_READ_REPORT: {
         replyLen = tmMemReadReport.rememberRequestedSize;
         break;
       }
-      case mpsoc::TM_CAM_CMD_RPT:
+      case PlocMpSoCCommands::TM_CAM_CMD_RPT:
         // Read acknowledgment, camera and execution report in one go because length of camera
         // report is not fixed
         replyLen = SpacePacket::PACKET_MAX_SIZE;
@@ -827,7 +799,8 @@ size_t PlocMPSoCHandler::getNextReplyLength(DeviceCommandId_t commandId) {
     }
   } else {
     sif::debug << "PlocMPSoCHandler::getNextReplyLength: No entry for reply with reply id "
-               << std::hex << nextReplyId << " in deviceReplyMap" << std::endl;
+               << std::hex << static_cast<DeviceCommandId_t>(nextReplyId) << " in deviceReplyMap"
+               << std::endl;
   }
 
   return replyLen;
@@ -924,31 +897,33 @@ void PlocMPSoCHandler::handleDeviceTM(const uint8_t* data, size_t dataSize,
 }
 
 void PlocMPSoCHandler::disableAllReplies() {
-  using namespace mpsoc;
   DeviceReplyMap::iterator iter;
 
   /* Disable ack reply */
-  iter = deviceReplyMap.find(ACK_REPORT);
+  iter = deviceReplyMap.find(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::ACK_REPORT));
   DeviceReplyInfo* info = &(iter->second);
   info->delayCycles = 0;
   info->command = deviceCommandMap.end();
 
   DeviceCommandId_t commandId = getPendingCommand();
 
+  PlocMpSoCCommands enumCommand = PlocMpSoCCommands(commandId);
+
   /* If the command expects a telemetry packet the appropriate tm reply will be disabled here */
-  switch (commandId) {
-    case TC_MEM_WRITE:
+  switch (enumCommand) {
+    case PlocMpSoCCommands::TC_MEM_WRITE:
       break;
-    case TC_MEM_READ: {
-      iter = deviceReplyMap.find(TM_MEMORY_READ_REPORT);
+    case PlocMpSoCCommands::TC_MEM_READ: {
+      iter = deviceReplyMap.find(
+          static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TM_MEMORY_READ_REPORT));
       info = &(iter->second);
       info->delayCycles = 0;
       info->active = false;
       info->command = deviceCommandMap.end();
       break;
     }
-    case TC_CAM_CMD_SEND: {
-      iter = deviceReplyMap.find(TM_CAM_CMD_RPT);
+    case PlocMpSoCCommands::TC_CAM_CMD_SEND: {
+      iter = deviceReplyMap.find(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::TM_CAM_CMD_RPT));
       info = &(iter->second);
       info->delayCycles = 0;
       info->active = false;
@@ -964,11 +939,11 @@ void PlocMPSoCHandler::disableAllReplies() {
 
   /* We always need to disable the execution report reply here */
   disableExeReportReply();
-  nextReplyId = mpsoc::NONE;
+  nextReplyId = PlocMpSoCCommands::NONE;
 }
 
-void PlocMPSoCHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status) {
-  DeviceReplyIter iter = deviceReplyMap.find(replyId);
+void PlocMPSoCHandler::sendFailureReport(PlocMpSoCCommands replyId, ReturnValue_t status) {
+  DeviceReplyIter iter = deviceReplyMap.find(static_cast<DeviceCommandId_t>(replyId));
   if (iter == deviceReplyMap.end()) {
     sif::debug << "PlocMPSoCHandler::sendFailureReport: Reply not in reply map" << std::endl;
     return;
@@ -985,7 +960,8 @@ void PlocMPSoCHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnValue_
 }
 
 void PlocMPSoCHandler::disableExeReportReply() {
-  DeviceReplyIter iter = deviceReplyMap.find(mpsoc::EXE_REPORT);
+  DeviceReplyIter iter =
+      deviceReplyMap.find(static_cast<DeviceCommandId_t>(PlocMpSoCCommands::EXE_REPORT));
   DeviceReplyInfo* info = &(iter->second);
   info->delayCycles = 0;
   info->command = deviceCommandMap.end();

linux/devices/ploc/PlocMPSoCHandler.h

@@ -48,8 +48,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
                    object_id_t supervisorHandler);
   virtual ~PlocMPSoCHandler();
   virtual ReturnValue_t initialize() override;
-  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                              const uint8_t* data, size_t size) override;
+  ReturnValue_t executeAction(Action* action) override;
   void performOperationHook() override;
   MessageQueueIF* getCommandQueuePtr() override;
   void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) override;
@@ -58,6 +57,22 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
   void completionSuccessfulReceived(ActionId_t actionId) override;
   void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) override;
 
+  ReturnValue_t handleAction(PlocMpSoCMemWriteAction* action);
+  ReturnValue_t handleAction(PlocMpSoCMemReadAction* action);
+  ReturnValue_t handleAction(PlocMpSoCFlashDeleteAction* action);
+  ReturnValue_t handleAction(PlocMpSoCReplayStartAction* action);
+  ReturnValue_t handleAction(PlocMpSoCReplayStopAction* action);
+  ReturnValue_t handleAction(PlocMpSoCReplayWriteSequenceAction* action);
+  ReturnValue_t handleAction(PlocMpSoCDownlinkPwrOnAction* action);
+  ReturnValue_t handleAction(PlocMpSoCDownlinkPwrOffAction* action);
+  ReturnValue_t handleAction(PlocMpSoCModeReplayAction* action);
+  ReturnValue_t handleAction(PlocMpSoCCamCmdSendAction* action);
+  ReturnValue_t handleAction(PlocMpSoCModeIdleAction* action);
+  ReturnValue_t handleAction(PlocMpSoCFlashWriteAction* action);
+  ReturnValue_t handleAction(PlocMpSoCUartTxTristateAction* action);
+  ReturnValue_t handleAction(PlocMpSoCReleaseUartTxAction* action);
+  ReturnValue_t handleAction(PlocMpSoCObswResetSeqCountAction* action);
+
  protected:
   void doStartUp() override;
   void doShutDown() override;
@@ -121,7 +136,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
    * because the PLOC sends as reply to each command at least one acknowledgment and execution
    * report.
    */
-  DeviceCommandId_t nextReplyId = mpsoc::NONE;
+  PlocMpSoCCommands nextReplyId = PlocMpSoCCommands::NONE;
 
   UartComIF* uartComIf = nullptr;
 
@@ -172,6 +187,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
   ReturnValue_t prepareTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcCamCmdSend(const uint8_t* commandData, size_t commandDataLen);
   ReturnValue_t prepareTcModeIdle();
+
   /**
    * @brief   Copies space packet into command buffer
    */
@@ -248,7 +264,7 @@ class PlocMPSoCHandler : public DeviceHandlerBase, public CommandsActionsIF {
    * @param replyId   The id of the reply which signals a failure.
    * @param status    A status byte which gives information about the failure type.
    */
-  void sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status);
+  void sendFailureReport(PlocMpSoCCommands replyId, ReturnValue_t status);
 
   /**
    * @brief   This function disables the execution report reply. Within this function also the

linux/devices/ploc/PlocMPSoCHelper.h

@@ -10,7 +10,7 @@
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tmtcservices/SourceSequenceCounter.h"
 #include "fsfw_hal/linux/uart/UartComIF.h"
-#include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
+#include "linux/devices/devicedefinitions/PlocMPSoCCommonDefinitions.h"
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/memory/SdCardManager.h"
 #endif

linux/devices/ploc/PlocMemoryDumper.cpp

@@ -40,40 +40,27 @@ ReturnValue_t PlocMemoryDumper::performOperation(uint8_t operationCode) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t PlocMemoryDumper::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                              const uint8_t* data, size_t size) {
+ReturnValue_t PlocMemoryDumper::executeAction(Action* action) { return action->handle(); }
+
+ReturnValue_t PlocMemoryDumper::handleAction(DumpMemoryAction* action) {
   if (state != State::IDLE) {
     return IS_BUSY;
   }
 
-  switch (actionId) {
-    case DUMP_MRAM: {
-      size_t deserializeSize = sizeof(mram.startAddress) + sizeof(mram.endAddress);
-      SerializeAdapter::deSerialize(&mram.startAddress, &data, &deserializeSize,
-                                    SerializeIF::Endianness::BIG);
-      SerializeAdapter::deSerialize(&mram.endAddress, &data, &deserializeSize,
-                                    SerializeIF::Endianness::BIG);
-      if (mram.endAddress > MAX_MRAM_ADDRESS) {
-        return MRAM_ADDRESS_TOO_HIGH;
-      }
-      if (mram.endAddress <= mram.startAddress) {
-        return MRAM_INVALID_ADDRESS_COMBINATION;
-      }
-      state = State::COMMAND_FIRST_MRAM_DUMP;
-      break;
-    }
-    default: {
-      sif::warning << "PlocMemoryDumper::executeAction: Received command with invalid action id"
-                   << std::endl;
-      return INVALID_ACTION_ID;
-    }
+  if (action->endAddress <= action->startAddress) {
+    return MRAM_INVALID_ADDRESS_COMBINATION;
   }
+  mram.startAddress = action->startAddress;
+  mram.endAddress = action->endAddress;
+  state = State::COMMAND_FIRST_MRAM_DUMP;
 
   return EXECUTION_FINISHED;
 }
 
 MessageQueueId_t PlocMemoryDumper::getCommandQueue() const { return commandQueue->getId(); }
 
+ActionHelper* PlocMemoryDumper::getActionHelper() { return &actionHelper; }
+
 MessageQueueIF* PlocMemoryDumper::getCommandQueuePtr() { return commandQueue; }
 
 void PlocMemoryDumper::readCommandQueue() {

linux/devices/ploc/PlocMemoryDumper.h

@@ -2,6 +2,7 @@
 #define MISSION_DEVICES_PLOCMEMORYDUMPER_H_
 
 #include <linux/devices/devicedefinitions/PlocMemDumpDefinitions.h>
+#include <linux/devices/devicedefinitions/PlocMemDumpActions.h>
 #include <linux/devices/devicedefinitions/PlocSupervisorDefinitions.h>
 
 #include "OBSWConfig.h"
@@ -37,8 +38,9 @@ class PlocMemoryDumper : public SystemObject,
   virtual ~PlocMemoryDumper();
 
   ReturnValue_t performOperation(uint8_t operationCode = 0) override;
-  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                              const uint8_t* data, size_t size);
+  ReturnValue_t executeAction(Action* action) override;
+  ReturnValue_t handleAction(DumpMemoryAction* action);
+  ActionHelper *getActionHelper() override;
   MessageQueueId_t getCommandQueue() const;
   ReturnValue_t initialize() override;
   MessageQueueIF* getCommandQueuePtr() override;
@@ -53,9 +55,6 @@ class PlocMemoryDumper : public SystemObject,
 
   static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MEMORY_DUMPER;
 
-  //! [EXPORT] : [COMMENT] The capacity of the MRAM amounts to 512 kB. Thus the maximum address must
-  //! not be higher than 0x7d000.
-  static const ReturnValue_t MRAM_ADDRESS_TOO_HIGH = MAKE_RETURN_CODE(0xA0);
   //! [EXPORT] : [COMMENT] The specified end address is lower than the start address
   static const ReturnValue_t MRAM_INVALID_ADDRESS_COMBINATION = MAKE_RETURN_CODE(0xA1);
 
@@ -73,7 +72,6 @@ class PlocMemoryDumper : public SystemObject,
 
   // Maximum size of mram dump which can be retrieved with one command
   static const uint32_t MAX_MRAM_DUMP_SIZE = 100000;
-  static const uint32_t MAX_MRAM_ADDRESS = 0x7d000;
 
   MessageQueueIF* commandQueue = nullptr;
 

linux/devices/ploc/PlocSupervisorHandler.cpp

@@ -80,12 +80,15 @@ void PlocSupervisorHandler::performOperationHook() {
   }
 }
 
-ReturnValue_t PlocSupervisorHandler::executeAction(ActionId_t actionId,
-                                                   MessageQueueId_t commandedBy,
-                                                   const uint8_t* data, size_t size) {
+ReturnValue_t PlocSupervisorHandler::executeAction(Action* action) {
   using namespace supv;
   ReturnValue_t result = RETURN_OK;
 
+  //TODO
+  ActionId_t actionId = 0;
+  uint8_t *data = nullptr;
+  size_t size = 0;
+
   switch (actionId) {
     case TERMINATE_SUPV_HELPER: {
       supvHelper->stopProcess();
@@ -138,7 +141,7 @@ ReturnValue_t PlocSupervisorHandler::executeAction(ActionId_t actionId,
     default:
       break;
   }
-  return DeviceHandlerBase::executeAction(actionId, commandedBy, data, size);
+  return DeviceHandlerBase::executeAction(action);
 }
 
 void PlocSupervisorHandler::doStartUp() {
@@ -828,7 +831,7 @@ void PlocSupervisorHandler::handleEvent(EventMessage* eventMessage) {
           event == PlocSupvHelper::SUPV_UPDATE_SUCCESSFUL ||
           event == PlocSupvHelper::SUPV_CONTINUE_UPDATE_FAILED ||
           event == PlocSupvHelper::SUPV_CONTINUE_UPDATE_SUCCESSFUL) {
-        result = this->executeAction(supv::SHUTDOWN_MPSOC, NO_COMMANDER, nullptr, 0);
+        //TODO result = this->executeAction(supv::SHUTDOWN_MPSOC, NO_COMMANDER, nullptr, 0);
         if (result != RETURN_OK) {
           triggerEvent(SUPV_MPSOC_SHUWDOWN_BUILD_FAILED);
           sif::warning << "PlocSupervisorHandler::handleEvent: Failed to build MPSoC shutdown "

linux/devices/ploc/PlocSupervisorHandler.h

@@ -34,8 +34,7 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
 
   virtual ReturnValue_t initialize() override;
   void performOperationHook() override;
-  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                              const uint8_t* data, size_t size) override;
+  ReturnValue_t executeAction(Action* action) override;
 
  protected:
   void doStartUp() override;

linux/devices/startracker/StarTrackerHandler.cpp

@@ -91,10 +91,14 @@ ReturnValue_t StarTrackerHandler::initialize() {
   return RETURN_OK;
 }
 
-ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                                const uint8_t* data, size_t size) {
+ReturnValue_t StarTrackerHandler::executeAction(Action* action) {
   ReturnValue_t result = RETURN_OK;
 
+  //TODO
+  ActionId_t actionId = 0;
+  uint8_t *data = nullptr;
+  size_t size = 0;
+
   switch (actionId) {
     case (startracker::STOP_IMAGE_LOADER): {
       strHelper->stopProcess();
@@ -209,7 +213,7 @@ ReturnValue_t StarTrackerHandler::executeAction(ActionId_t actionId, MessageQueu
     default:
       break;
   }
-  return DeviceHandlerBase::executeAction(actionId, commandedBy, data, size);
+  return DeviceHandlerBase::executeAction(action);
 }
 
 void StarTrackerHandler::performOperationHook() {

linux/devices/startracker/StarTrackerHandler.h

@@ -44,8 +44,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
    * @brief   Overwrite this function from DHB to handle commands executed by the str image
    *          loader task.
    */
-  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                              const uint8_t* data, size_t size) override;
+  ReturnValue_t executeAction(Action* action) override;
 
   void performOperationHook() override;
 

linux/fsfwconfig/events/subsystemIdRanges.h

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

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
  * @brief    Auto-generated event translation file. Contains 209 translations.
  * @details
- * Generated on: 2022-06-27 09:14:37
+ * Generated on: 2022-08-12 12:30:32
  */
 #include "translateEvents.h"
 

linux/fsfwconfig/objects/systemObjectList.h

@@ -2,6 +2,7 @@
 #define LINUX_FSFWCONFIG_OBJECTS_SYSTEMOBJECTLIST_H_
 
 #include <fsfw/objectmanager/frameworkObjects.h>
+#include <fsfw/introspection/ClasslessEnum.h>
 
 #include <cstdint>
 
@@ -33,36 +34,34 @@ Fourth byte is a unique counter.
 
  */
 namespace objects {
-enum sourceObjects : uint32_t {
+FSFW_CLASSLESS_ENUM(systemObjects, uint32_t,
   /* 0x53 reserved for FSFW */
-  FW_ADDRESS_START = PUS_SERVICE_1_VERIFICATION,
-  FW_ADDRESS_END = TIME_STAMPER,
-  PUS_SERVICE_6 = 0x51000500,
+((PUS_SERVICE_6, 0x51000500, "PUS_SERVICE_6"))
 
-  CCSDS_IP_CORE_BRIDGE = 0x73500000,
-  TM_FUNNEL = 0x73000100,
+((CCSDS_IP_CORE_BRIDGE, 0x73500000, "CCSDS_IP_CORE_BRIDGE"))
+((TM_FUNNEL, 0x73000100, "TM_FUNNEL"))
 
   /* 0x49 ('I') for Communication Interfaces **/
-  ARDUINO_COM_IF = 0x49000000,
-  CSP_COM_IF = 0x49050001,
-  I2C_COM_IF = 0x49040002,
-  UART_COM_IF = 0x49030003,
-  SPI_MAIN_COM_IF = 0x49020004,
-  GPIO_IF = 0x49010005,
-  SPI_RW_COM_IF = 0x49020005,
-  SPI_RTD_COM_IF = 0x49020006,
+((ARDUINO_COM_IF, 0x49000000, "ARDUINO_COM_IF"))
+((CSP_COM_IF, 0x49050001, "CSP_COM_IF"))
+((I2C_COM_IF, 0x49040002, "I2C_COM_IF"))
+((UART_COM_IF, 0x49030003, "UART_COM_IF"))
+((SPI_MAIN_COM_IF, 0x49020004, "SPI_MAIN_COM_IF"))
+((GPIO_IF, 0x49010005, "GPIO_IF"))
+((SPI_RW_COM_IF, 0x49020005, "SPI_RW_COM_IF"))
+((SPI_RTD_COM_IF, 0x49020006, "SPI_RTD_COM_IF"))
 
   /* 0x54 ('T') for test handlers */
-  TEST_TASK = 0x54694269,
-  LIBGPIOD_TEST = 0x54123456,
-  SPI_TEST = 0x54000010,
-  UART_TEST = 0x54000020,
-  I2C_TEST = 0x54000030,
-  DUMMY_INTERFACE = 0x5400CAFE,
-  DUMMY_HANDLER = 0x5400AFFE,
-  P60DOCK_TEST_TASK = 0x00005060,
-  DUMMY_COM_IF = 0x54000040
-};
+((TEST_TASK, 0x54694269, "TEST_TASK"))
+((LIBGPIOD_TEST, 0x54123456, "LIBGPIOD_TEST"))
+((SPI_TEST, 0x54000010, "SPI_TEST"))
+((UART_TEST, 0x54000020, "UART_TEST"))
+((I2C_TEST, 0x54000030, "I2C_TEST"))
+((DUMMY_INTERFACE, 0x5400CAFE, "DUMMY_INTERFACE"))
+((DUMMY_HANDLER, 0x5400AFFE, "DUMMY_HANDLER"))
+((P60DOCK_TEST_TASK, 0x00005060, "P60DOCK_TEST_TASK"))
+((DUMMY_COM_IF, 0x54000040, "DUMMY_COM_IF"))
+)
 }
 
 #endif /* LINUX_FSFWCONFIG_OBJECTS_SYSTEMOBJECTLIST_H_ */

linux/fsfwconfig/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 132 translations.
- * Generated on: 2022-06-27 09:14:34
+ * Generated on: 2022-08-12 12:30:32
  */
 #include "translateObjects.h"
 

linux/fsfwconfig/returnvalues/classIds.h

@@ -1,7 +1,7 @@
 #ifndef FSFWCONFIG_RETURNVALUES_CLASSIDS_H_
 #define FSFWCONFIG_RETURNVALUES_CLASSIDS_H_
 
-#include <common/config/commonClassIds.h>
+#include <config/commonClassIds.h>
 #include <fsfw/returnvalues/FwClassIds.h>
 
 /**

linux/obc/PdecDefinitions.h

@@ -0,0 +1,24 @@
+#include <fsfw/action/MinMaxParameter.h>
+#include <fsfw/action/TemplateAction.h>
+#include <fsfw/introspection/Enum.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+
+class PdecHandler;
+
+FSFW_ENUM(PdecCommands, DeviceCommandId_t,((PRINT_CLCW, "Print CLCW")) ((PRINT_PDEC_MON, "Print PDEC Mon Status")))
+
+class PdecPrintClcwAction
+    : public TemplateAction<PdecHandler, PdecPrintClcwAction,
+                            PdecCommands> {
+ public:
+  PdecPrintClcwAction(PdecHandler *owner)
+      : TemplateAction(owner, PdecCommands::PRINT_CLCW) {};
+};
+
+class PdecPrintMonAction
+    : public TemplateAction<PdecHandler, PdecPrintMonAction,
+                            PdecCommands> {
+ public:
+  PdecPrintMonAction(PdecHandler *owner)
+      : TemplateAction(owner, PdecCommands::PRINT_PDEC_MON) {};
+};

linux/obc/PdecHandler.cpp

@@ -79,6 +79,8 @@ ReturnValue_t PdecHandler::initialize() {
 
 MessageQueueId_t PdecHandler::getCommandQueue() const { return commandQueue->getId(); }
 
+ActionHelper* PdecHandler::getActionHelper() { return &actionHelper; }
+
 void PdecHandler::writePdecConfig() {
   PdecConfig pdecConfig;
 
@@ -514,16 +516,14 @@ std::string PdecHandler::getMonStatusString(uint32_t status) {
   }
 }
 
-ReturnValue_t PdecHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                         const uint8_t* data, size_t size) {
-  switch (actionId) {
-    case PRINT_CLCW:
-      printClcw();
-      return EXECUTION_FINISHED;
-    case PRINT_PDEC_MON:
-      printPdecMon();
-      return EXECUTION_FINISHED;
-    default:
-      return COMMAND_NOT_IMPLEMENTED;
-  }
+ReturnValue_t PdecHandler::executeAction(Action* action) { return action->handle(); }
+
+ReturnValue_t PdecHandler::handleAction(PdecPrintClcwAction* action) {
+  printClcw();
+  return EXECUTION_FINISHED;
+}
+
+ReturnValue_t PdecHandler::handleAction(PdecPrintMonAction* action) {
+  printPdecMon();
+  return EXECUTION_FINISHED;
 }

linux/obc/PdecHandler.h

@@ -3,6 +3,7 @@
 
 #include "OBSWConfig.h"
 #include "PdecConfig.h"
+#include "PdecDefinitions.h"
 #include "fsfw/action/ActionHelper.h"
 #include "fsfw/action/HasActionsIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
@@ -57,8 +58,10 @@ class PdecHandler : public SystemObject,
 
   MessageQueueId_t getCommandQueue() const;
 
-  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                              const uint8_t* data, size_t size) override;
+  ActionHelper* getActionHelper() override;
+  ReturnValue_t executeAction(Action* action) override;
+  ReturnValue_t handleAction(PdecPrintClcwAction* action);
+  ReturnValue_t handleAction(PdecPrintMonAction* action);
 
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PDEC_HANDLER;
 
@@ -89,9 +92,6 @@ class PdecHandler : public SystemObject,
   static const ReturnValue_t AD_DISCARDED_WAIT = MAKE_RETURN_CODE(0xA4);
   static const ReturnValue_t AD_DISCARDED_NS_VS = MAKE_RETURN_CODE(0xA5);
 
-  //! [EXPORT] : [COMMENT] Received action message with unknown action id
-  static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xB0);
-
   static const ReturnValue_t NO_REPORT = MAKE_RETURN_CODE(0xA6);
   //! Error in version number and reserved A and B fields
   static const ReturnValue_t ERROR_VERSION_NUMBER = MAKE_RETURN_CODE(0xA7);
@@ -110,11 +110,6 @@ class PdecHandler : public SystemObject,
 
   static const uint32_t QUEUE_SIZE = common::CCSDS_HANDLER_QUEUE_SIZE;
 
-  // Action IDs
-  static const ActionId_t PRINT_CLCW = 0;
-  // Print PDEC monitor register
-  static const ActionId_t PRINT_PDEC_MON = 1;
-
   static const uint8_t STAT_POSITION = 31;
   static const uint8_t FRAME_ANA_POSITION = 28;
   static const uint8_t IREASON_POSITION = 25;
@@ -371,6 +366,9 @@ class PdecHandler : public SystemObject,
 
   ActionHelper actionHelper;
 
+  PdecPrintClcwAction pdecPrintClcwAction = PdecPrintClcwAction(this);
+  PdecPrintMonAction pdecPrintMonAction = PdecPrintMonAction(this);
+
   StorageManagerIF* tcStore = nullptr;
 
   MessageQueueIF* commandQueue = nullptr;

mission/controller/AcsController.cpp

@@ -0,0 +1,100 @@
+#include <fsfw/datapool/PoolReadGuard.h>
+#include "AcsController.h"
+
+AcsController::AcsController(object_id_t objectId)
+    : ExtendedControllerBase(objectId, objects::NO_OBJECT),
+      mgmData(this) {}
+
+ReturnValue_t AcsController::handleCommandMessage(CommandMessage *message) {
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+void AcsController::performControlOperation() {
+  switch (internalState) {
+    case InternalState::STARTUP: {
+      initialCountdown.resetTimer();
+      internalState = InternalState::INITIAL_DELAY;
+      return;
+    }
+    case InternalState::INITIAL_DELAY: {
+      if (initialCountdown.hasTimedOut()) {
+        internalState = InternalState::READY;
+      }
+      return;
+    }
+    case InternalState::READY: {
+      break;
+    }
+    default:
+      break;
+  }
+
+  {
+    PoolReadGuard pg(&mgmData);
+    if (pg.getReadResult() == RETURN_OK) {
+        copyMgmData();
+    }
+  }
+}
+
+ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                     LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(acsctrl::PoolIds::MGM_0_LIS3_UT, &mgm0PoolVec);
+  localDataPoolMap.emplace(acsctrl::PoolIds::MGM_1_RM3100_UT, &mgm1PoolVec);
+  localDataPoolMap.emplace(acsctrl::PoolIds::MGM_2_LIS3_UT, &mgm2PoolVec);
+  localDataPoolMap.emplace(acsctrl::PoolIds::MGM_3_RM3100_UT, &mgm3PoolVec);
+  localDataPoolMap.emplace(acsctrl::PoolIds::MGM_IMTQ_CAL_NT, &imtqMgmPoolVec);
+  localDataPoolMap.emplace(acsctrl::PoolIds::MGM_IMTQ_CAL_ACT_STATUS, &imtqCalActStatus);
+  poolManager.subscribeForPeriodicPacket(mgmData.getSid(), false,  5.0, false);
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+LocalPoolDataSetBase *AcsController::getDataSetHandle(sid_t sid) {
+  if (sid == mgmData.getSid()) {
+    return &mgmData;
+  }
+  return nullptr;
+}
+
+ReturnValue_t AcsController::checkModeCommand(Mode_t mode, Submode_t submode,
+                                              uint32_t *msToReachTheMode) {
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ModeDefinitionHelper AcsController::getModeDefinitionHelper() {
+  return ModeDefinitionHelper::create<ControllerModes, DefaultSubmode>();
+}
+
+void AcsController::copyMgmData() {
+  {
+    PoolReadGuard pg(&mgm0Lis3Set);
+    if(pg.getReadResult() == RETURN_OK) {
+      std::memcpy(mgmData.mgm0Lis3.value, mgm0Lis3Set.fieldStrengths.value, 3 * sizeof(float));
+    }
+  }
+  {
+    PoolReadGuard pg(&mgm1Rm3100Set);
+    if(pg.getReadResult() == RETURN_OK) {
+      std::memcpy(mgmData.mgm1Rm3100.value, mgm1Rm3100Set.fieldStrengths.value, 3 * sizeof(float));
+    }
+  }
+  {
+    PoolReadGuard pg(&mgm2Lis3Set);
+    if(pg.getReadResult() == RETURN_OK) {
+      std::memcpy(mgmData.mgm2Lis3.value, mgm2Lis3Set.fieldStrengths.value, 3 * sizeof(float));
+    }
+  }
+  {
+    PoolReadGuard pg(&mgm3Rm3100Set);
+    if(pg.getReadResult() == RETURN_OK) {
+      std::memcpy(mgmData.mgm3Rm3100.value, mgm3Rm3100Set.fieldStrengths.value, 3 * sizeof(float));
+    }
+  }
+  {
+    PoolReadGuard pg(&imtqMgmSet);
+    if(pg.getReadResult() == RETURN_OK) {
+      std::memcpy(mgmData.imtqCal.value, imtqMgmSet.mgmXyz.value, 3 * sizeof(int32_t));
+      mgmData.actuationCalStatus.value = imtqMgmSet.coilActuationStatus.value;
+    }
+  }
+}

mission/controller/AcsController.h

@@ -0,0 +1,57 @@
+#ifndef MISSION_CONTROLLER_ACSCONTROLLER_H_
+#define MISSION_CONTROLLER_ACSCONTROLLER_H_
+
+#include <commonObjects.h>
+#include "controllerdefinitions/AcsCtrlDefinitions.h"
+#include <fsfw/controller/ExtendedControllerBase.h>
+#include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h"
+#include "fsfw_hal/devicehandlers/MgmRM3100Handler.h"
+#include "mission/devices/devicedefinitions/IMTQHandlerDefinitions.h"
+
+class AcsController : public ExtendedControllerBase {
+ public:
+  static constexpr dur_millis_t INIT_DELAY = 500;
+
+  AcsController(object_id_t objectId);
+
+ private:
+  enum class InternalState { STARTUP, INITIAL_DELAY, READY };
+
+  InternalState internalState = InternalState::STARTUP;
+
+  ReturnValue_t handleCommandMessage(CommandMessage* message) override;
+  void performControlOperation() override;
+
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                        LocalDataPoolManager& poolManager) override;
+  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+
+  // Mode abstract functions
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t* msToReachTheMode) override;
+
+                                 ModeDefinitionHelper getModeDefinitionHelper() override;
+
+  // MGMs
+  acsctrl::MgmData mgmData;
+
+  MGMLIS3MDL::MgmPrimaryDataset mgm0Lis3Set = MGMLIS3MDL::MgmPrimaryDataset(objects::MGM_0_LIS3_HANDLER);
+  RM3100::Rm3100PrimaryDataset mgm1Rm3100Set = RM3100::Rm3100PrimaryDataset(objects::MGM_1_RM3100_HANDLER);
+  MGMLIS3MDL::MgmPrimaryDataset mgm2Lis3Set = MGMLIS3MDL::MgmPrimaryDataset(objects::MGM_2_LIS3_HANDLER);
+  RM3100::Rm3100PrimaryDataset mgm3Rm3100Set = RM3100::Rm3100PrimaryDataset(objects::MGM_3_RM3100_HANDLER);
+  IMTQ::CalibratedMtmMeasurementSet imtqMgmSet = IMTQ::CalibratedMtmMeasurementSet(objects::IMTQ_HANDLER);
+
+  PoolEntry<float> mgm0PoolVec = PoolEntry<float>(3);
+  PoolEntry<float> mgm1PoolVec = PoolEntry<float>(3);
+  PoolEntry<float> mgm2PoolVec = PoolEntry<float>(3);
+  PoolEntry<float> mgm3PoolVec = PoolEntry<float>(3);
+  PoolEntry<int32_t> imtqMgmPoolVec = PoolEntry<int32_t>(3);
+  PoolEntry<uint8_t> imtqCalActStatus = PoolEntry<uint8_t>();
+  void copyMgmData();
+
+  // Initial delay to make sure all pool variables have been initialized their owners
+  Countdown initialCountdown = Countdown(INIT_DELAY);
+  // Sun Sensors
+};
+
+#endif /* MISSION_CONTROLLER_ACSCONTROLLER_H_ */

mission/controller/CMakeLists.txt

@@ -1,3 +1,4 @@
 if(TGT_BSP MATCHES "arm/q7s" OR TGT_BSP MATCHES "")
-	target_sources(${LIB_EIVE_MISSION} PRIVATE ThermalController.cpp)
+  target_sources(${LIB_EIVE_MISSION} PRIVATE ThermalController.cpp
+                                             AcsController.cpp)
 endif()

mission/controller/ThermalController.cpp

@@ -200,9 +200,9 @@ ReturnValue_t ThermalController::initializeLocalDataPool(localpool::DataPool& lo
   localDataPoolMap.emplace(thermalControllerDefinitions::TEMP_ADC_PAYLOAD_PCDU,
                            new PoolEntry<float>({0.0}));
 
-  poolManager.subscribeForPeriodicPacket(sensorTemperatures.getSid(), true, 1.0, false);
-  poolManager.subscribeForPeriodicPacket(susTemperatures.getSid(), true, 1.0, false);
-  poolManager.subscribeForPeriodicPacket(deviceTemperatures.getSid(), true, 1.0, false);
+  poolManager.subscribeForPeriodicPacket(sensorTemperatures.getSid(), false, 1.0, false);
+  poolManager.subscribeForPeriodicPacket(susTemperatures.getSid(), false, 1.0, false);
+  poolManager.subscribeForPeriodicPacket(deviceTemperatures.getSid(), false, 1.0, false);
 
   return RETURN_OK;
 }
@@ -231,6 +231,10 @@ ReturnValue_t ThermalController::checkModeCommand(Mode_t mode, Submode_t submode
   return RETURN_OK;
 }
 
+ModeDefinitionHelper ThermalController::getModeDefinitionHelper() {
+  return ModeDefinitionHelper::create<ControllerModes, DefaultSubmode>();
+}
+
 void ThermalController::copySensors() {
   PoolReadGuard pg0(&max31865Set0);
   if (pg0.getReadResult() == HasReturnvaluesIF::RETURN_OK) {

mission/controller/ThermalController.h

@@ -27,6 +27,8 @@ class ThermalController : public ExtendedControllerBase {
   virtual ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                          uint32_t* msToReachTheMode) override;
 
+  ModeDefinitionHelper getModeDefinitionHelper() override;
+
  private:
   static const uint32_t DELAY = 500;
 

mission/controller/controllerdefinitions/AcsCtrlDefinitions.h

@@ -0,0 +1,48 @@
+#ifndef MISSION_CONTROLLER_CONTROLLERDEFINITIONS_ACSCTRLDEFINITIONS_H_
+#define MISSION_CONTROLLER_CONTROLLERDEFINITIONS_ACSCTRLDEFINITIONS_H_
+
+#include <fsfw/datapoollocal/localPoolDefinitions.h>
+#include <fsfw/datapoollocal/StaticLocalDataSet.h>
+#include <cstdint>
+
+namespace acsctrl {
+
+enum SetIds : uint32_t {
+  MGM_SENSOR_DATA
+};
+
+enum PoolIds : lp_id_t {
+  MGM_0_LIS3_UT,
+  MGM_1_RM3100_UT,
+  MGM_2_LIS3_UT,
+  MGM_3_RM3100_UT,
+  MGM_IMTQ_CAL_NT,
+  MGM_IMTQ_CAL_ACT_STATUS
+};
+
+
+static constexpr uint8_t MGM_SET_ENTRIES = 10;
+
+/**
+ * @brief   This dataset can be used to store the collected temperatures of all temperature sensors
+ */
+class MgmData : public StaticLocalDataSet<MGM_SET_ENTRIES> {
+public:
+  MgmData(HasLocalDataPoolIF* hkOwner) : StaticLocalDataSet(hkOwner, MGM_SENSOR_DATA) {}
+
+  // The ACS board measurement are in floating point uT
+  lp_vec_t<float, 3> mgm0Lis3 = lp_vec_t<float, 3>(sid.objectId, MGM_0_LIS3_UT, this);
+  lp_vec_t<float, 3> mgm1Rm3100 = lp_vec_t<float, 3>(sid.objectId, MGM_1_RM3100_UT, this);
+  lp_vec_t<float, 3> mgm2Lis3 = lp_vec_t<float, 3>(sid.objectId, MGM_2_LIS3_UT, this);
+  lp_vec_t<float, 3> mgm3Rm3100 = lp_vec_t<float, 3>(sid.objectId, MGM_3_RM3100_UT, this);
+  // The IMTQ measurements are in integer nT
+  lp_vec_t<int32_t, 3> imtqCal = lp_vec_t<int32_t, 3>(sid.objectId, MGM_IMTQ_CAL_NT, this);
+  lp_var_t<uint8_t> actuationCalStatus = lp_var_t<uint8_t>(sid.objectId,
+      MGM_IMTQ_CAL_ACT_STATUS, this);
+private:
+
+};
+
+}
+
+#endif /* MISSION_CONTROLLER_CONTROLLERDEFINITIONS_ACSCTRLDEFINITIONS_H_ */

mission/devices/ACUHandler.cpp

@@ -13,7 +13,7 @@ ACUHandler::~ACUHandler() {}
 
 ReturnValue_t ACUHandler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
   *id = GOMSPACE::REQUEST_HK_TABLE;
-  return buildCommandFromCommand(*id, NULL, 0);
+  return requestHkTableAction.handle();
 }
 
 void ACUHandler::fillCommandAndReplyMap() { GomspaceDeviceHandler::fillCommandAndReplyMap(); }

mission/devices/GomspaceDeviceHandler.cpp

@@ -33,59 +33,11 @@ ReturnValue_t GomspaceDeviceHandler::buildTransitionDeviceCommand(DeviceCommandI
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t GomspaceDeviceHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                             const uint8_t* commandData,
-                                                             size_t commandDataLen) {
-  ReturnValue_t result = childCommandHook(deviceCommand, commandData, commandDataLen);
-  switch (deviceCommand) {
-    case (GOMSPACE::PING): {
-      result = generatePingCommand(commandData, commandDataLen);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-      }
-      break;
-    }
-    case (GOMSPACE::REBOOT): {
-      generateRebootCommand();
-      break;
-    }
-    case (GOMSPACE::PARAM_SET): {
-      result = generateSetParamCommand(commandData, commandDataLen);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-      }
-      break;
-    }
-    case (GOMSPACE::PARAM_GET): {
-      result = generateGetParamCommand(commandData, commandDataLen);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-      }
-      break;
-    }
-    case (GOMSPACE::GNDWDT_RESET): {
-      result = generateResetWatchdogCmd();
-      if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-      }
-      break;
-    }
-    case (GOMSPACE::PRINT_SWITCH_V_I):
-    case (GOMSPACE::PRINT_LATCHUPS): {
-      result = printStatus(deviceCommand);
-      break;
-    }
-    case (GOMSPACE::REQUEST_HK_TABLE): {
-      result = generateRequestFullHkTableCmd(hkTableReplySize);
-      if (result != HasReturnvaluesIF::RETURN_OK) {
-        return result;
-      }
-      break;
-    }
-    default:
-      return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
-  }
-  return HasReturnvaluesIF::RETURN_OK;
+ReturnValue_t GomspaceDeviceHandler::handleAction(PrintSwitchVIAction* action) {
+  return printStatus(action->getId());
+}
+ReturnValue_t GomspaceDeviceHandler::handleAction(PrintLatchupsAction* action) {
+  return printStatus(action->getId());
 }
 
 void GomspaceDeviceHandler::fillCommandAndReplyMap() {
@@ -172,7 +124,8 @@ ReturnValue_t GomspaceDeviceHandler::interpretDeviceReply(DeviceCommandId_t id,
       if (*packet != PARAM_SET_OK) {
         return HasReturnvaluesIF::RETURN_FAILED;
       }
-      setParamCallback(setParamCacher, true);
+      // TODO fix
+      setParamCallback(setParamCacher.getParameter(), setParamCacher.getParameter(), setParamCacher.getParameterSize(), true);
       break;
     }
     case (GOMSPACE::REQUEST_HK_TABLE): {
@@ -187,29 +140,23 @@ ReturnValue_t GomspaceDeviceHandler::interpretDeviceReply(DeviceCommandId_t id,
 
 void GomspaceDeviceHandler::setNormalDatapoolEntriesInvalid() {}
 
-ReturnValue_t GomspaceDeviceHandler::generateSetParamCommand(const uint8_t* commandData,
-                                                             size_t commandDataLen) {
-  ReturnValue_t result =
-      setParamCacher.deSerialize(&commandData, &commandDataLen, SerializeIF::Endianness::BIG);
+ReturnValue_t GomspaceDeviceHandler::handleAction(ParamSetAction* action) {
   // This breaks layering but I really don't want to accept this command..
-  if (setParamCacher.getAddress() == PDU2::CONFIG_ADDRESS_OUT_EN_Q7S and
+  if (action->address == PDU2::CONFIG_ADDRESS_OUT_EN_Q7S and
       this->getObjectId() == objects::PDU2_HANDLER) {
     triggerEvent(power::SWITCHING_Q7S_DENIED, 0, 0);
     return HasReturnvaluesIF::RETURN_FAILED;
   }
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "GomspaceDeviceHandler: Failed to deserialize set parameter "
-                  "message"
-               << std::endl;
-    return result;
-  }
-  result = setParamCallback(setParamCacher, false);
+  //cache for later use
+  setParamCacher.set(action->address, action->parameter,
+                                          static_cast<uint8_t>(action->parameterSize.value));
+  ReturnValue_t result = setParamCallback(action->address, action->parameter,
+                                          static_cast<uint8_t>(action->parameterSize.value), false);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
   /* Get and check address */
-  uint16_t address = setParamCacher.getAddress();
-  if (address > maxConfigTableAddress) {
+  if (action->address > maxConfigTableAddress) {
     sif::error << "GomspaceDeviceHandler: Invalid address for set parameter "
                << "action" << std::endl;
     return INVALID_ADDRESS;
@@ -219,13 +166,52 @@ ReturnValue_t GomspaceDeviceHandler::generateSetParamCommand(const uint8_t* comm
   uint16_t total = 0;
   /* CSP reply only contains the transaction state */
   uint16_t querySize = 1;
-  const uint8_t* parameterPtr = setParamCacher.getParameter();
-  uint8_t parameterSize = setParamCacher.getParameterSize();
-  uint16_t payloadlength = sizeof(address) + parameterSize;
+  size_t parameterSize = 0;
+  uint8_t parameterBytes[4];
+  uint8_t* uselessPointer = parameterBytes;
+  switch (action->parameterSize.value) {
+    case ParamSetAction::ParameterByteSize::ONE_BYTE: {
+      if (action->parameter > 255) {
+        return INVALID_PARAMETERS;
+      }
+      uint8_t oneByte = action->parameter.value;
+      result = SerializeAdapter::serialize<uint8_t>(&oneByte, &uselessPointer, &parameterSize,
+                                                    sizeof(parameterBytes),
+                                                    SerializeIF::Endianness::BIG);
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+      }
+      parameterSize = 1;
+    } break;
+    case ParamSetAction::ParameterByteSize::TWO_BYTES: {
+      if (action->parameter > 65535) {
+        return INVALID_PARAMETERS;
+      }
+      uint16_t twoBytes = action->parameter.value;
+      result = SerializeAdapter::serialize<uint16_t>(&twoBytes, &uselessPointer, &parameterSize,
+                                                     sizeof(parameterBytes),
+                                                     SerializeIF::Endianness::BIG);
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+      }
+      parameterSize = 2;
+    } break;
+    case ParamSetAction::ParameterByteSize::FOUR_BYTES:
+      result = SerializeAdapter::serialize<uint32_t>(&(action->parameter.value), &uselessPointer,
+                                                     &parameterSize, sizeof(parameterBytes),
+                                                     SerializeIF::Endianness::BIG);
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        return result;
+      }
+      parameterSize = 4;
+      break;
+  }
+
+  uint16_t payloadlength = sizeof(action->address) + parameterSize;
 
   /* Generate command for CspComIF */
-  CspSetParamCommand setParamCmd(querySize, payloadlength, checksum, seq, total, address,
-                                 parameterPtr, parameterSize);
+  CspSetParamCommand setParamCmd(querySize, payloadlength, checksum, seq, total, action->address,
+                                 parameterBytes, parameterSize);
   size_t cspPacketLen = 0;
   uint8_t* buffer = cspPacket;
   result = setParamCmd.serialize(&buffer, &cspPacketLen, sizeof(cspPacket),
@@ -249,34 +235,18 @@ ReturnValue_t GomspaceDeviceHandler::generateSetParamCommand(const uint8_t* comm
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t GomspaceDeviceHandler::generateGetParamCommand(const uint8_t* commandData,
-                                                             size_t commandDataLen) {
+ReturnValue_t GomspaceDeviceHandler::handleAction(ParamGetAction* action) {
   ReturnValue_t result;
-  /* Unpack the received action message */
-  GetParamMessageUnpacker getParamMessage;
-  result = getParamMessage.deSerialize(&commandData, &commandDataLen, SerializeIF::Endianness::BIG);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "Failed to deserialize message to extract information "
-                  "from get parameter message"
-               << std::endl;
-    return result;
-  }
-  /* Get an check table id to read from */
-  uint8_t tableId = getParamMessage.getTableId();
-  if (tableId != CONFIG_TABLE_ID && tableId != HK_TABLE_ID) {
-    sif::error << "GomspaceDeviceHandler: Invalid table id in get parameter"
-                  " message"
-               << std::endl;
-    return INVALID_TABLE_ID;
-  }
+  auto tableId = action->tableId.value;
+
   /* Get and check address */
-  uint16_t address = getParamMessage.getAddress();
-  if (address > maxHkTableAddress && tableId == HK_TABLE_ID) {
+  uint16_t address = action->address;
+  if (address > maxHkTableAddress && tableId == ParamGetAction::TableId::HK_TABLE_ID) {
     sif::error << "GomspaceDeviceHandler: Invalid address to get parameter from "
                << "housekeeping table" << std::endl;
     return INVALID_ADDRESS;
   }
-  if (address > maxConfigTableAddress && tableId == CONFIG_TABLE_ID) {
+  if (address > maxConfigTableAddress && tableId == ParamGetAction::TableId::CONFIG_TABLE_ID) {
     sif::error << "GomspaceDeviceHandler: Invalid address to get parameter from "
                << "configuration table" << std::endl;
     return INVALID_ADDRESS;
@@ -285,16 +255,11 @@ ReturnValue_t GomspaceDeviceHandler::generateGetParamCommand(const uint8_t* comm
   uint16_t checksum = GOMSPACE::IGNORE_CHECKSUM;
   uint16_t seq = 0;
   uint16_t total = 0;
-  uint8_t parameterSize = getParamMessage.getParameterSize();
-  if (parameterSize > sizeof(uint32_t)) {
-    sif::error << "GomspaceDeviceHandler: GET_PARAM: Invalid parameter "
-               << "size" << std::endl;
-    return INVALID_PARAM_SIZE;
-  }
+  uint8_t parameterSize = static_cast<uint8_t>(action->parameterSize.value);
   uint16_t querySize = parameterSize + GOMSPACE::GS_HDR_LENGTH;
 
   /* Generate the CSP command to send to the P60 Dock */
-  CspGetParamCommand getParamCmd(querySize, tableId, length, checksum, seq, total, address);
+  CspGetParamCommand getParamCmd(querySize, static_cast<uint8_t>(tableId), length, checksum, seq, total, address);
   size_t cspPacketLen = 0;
   uint8_t* buffer = cspPacket;
   result = getParamCmd.serialize(&buffer, &cspPacketLen, sizeof(cspPacket),
@@ -303,12 +268,14 @@ ReturnValue_t GomspaceDeviceHandler::generateGetParamCommand(const uint8_t* comm
     sif::error << "GomspaceDeviceHandler: Failed to serialize command to "
                << "get parameter" << std::endl;
   }
-  if (cspPacketLen > MAX_PACKET_LEN) {
+
+  // checked by serialize above
+  /* if (cspPacketLen > MAX_PACKET_LEN) {
     sif::error << "GomspaceDeviceHandler: Received invalid get parameter "
                   "command"
                << std::endl;
     return PACKET_TOO_LONG;
-  }
+  }*/
   rawPacket = cspPacket;
   rawPacketLen = cspPacketLen;
   rememberRequestedSize = querySize;
@@ -316,9 +283,8 @@ ReturnValue_t GomspaceDeviceHandler::generateGetParamCommand(const uint8_t* comm
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t GomspaceDeviceHandler::generatePingCommand(const uint8_t* commandData,
-                                                         size_t commandDataLen) {
-  CspPingCommand cspPingCommand(commandData, commandDataLen);
+ReturnValue_t GomspaceDeviceHandler::handleAction(PingAction* action) {
+  CspPingCommand cspPingCommand(&action->pingData.value, 1);  // TODO array
   size_t cspPacketLen = 0;
   uint8_t* buffer = cspPacket;
   ReturnValue_t result = cspPingCommand.serialize(&buffer, &cspPacketLen, sizeof(cspPacket),
@@ -327,24 +293,27 @@ ReturnValue_t GomspaceDeviceHandler::generatePingCommand(const uint8_t* commandD
     sif::error << "GomspaceDeviceHandler: Failed to serialize ping command" << std::endl;
     return result;
   }
+  /* Checked by the serialize function
   if (cspPacketLen > MAX_PACKET_LEN) {
     sif::error << "GomspaceDeviceHandler: Received invalid ping message" << std::endl;
     return PACKET_TOO_LONG;
-  }
+  }*/
   rawPacket = cspPacket;
   rawPacketLen = cspPacketLen;
   rememberCommandId = GOMSPACE::PING;
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-void GomspaceDeviceHandler::generateRebootCommand() {
+ReturnValue_t GomspaceDeviceHandler::handleAction(RebootAction* action) {
   uint8_t cspPort = GOMSPACE::REBOOT_PORT;
   uint16_t querySize = 0;
   *cspPacket = GOMSPACE::REBOOT_PORT;
+  // TODO the following two lines look strange...
   *(cspPacket + 1) = querySize;
   size_t cspPacketLen = sizeof(cspPort) + sizeof(cspPacketLen);
   rawPacket = cspPacket;
   rawPacketLen = cspPacketLen;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 ReturnValue_t GomspaceDeviceHandler::childCommandHook(DeviceCommandId_t cmd,
@@ -353,8 +322,8 @@ ReturnValue_t GomspaceDeviceHandler::childCommandHook(DeviceCommandId_t cmd,
   return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
 }
 
-ReturnValue_t GomspaceDeviceHandler::setParamCallback(SetParamMessageUnpacker& unpacker,
-                                                      bool afterExecution) {
+ReturnValue_t GomspaceDeviceHandler::setParamCallback(uint16_t address, uint32_t value,
+                                                      uint8_t valueBytes, bool afterExecution) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -396,7 +365,7 @@ ReturnValue_t GomspaceDeviceHandler::initializePduPool(
   return RETURN_OK;
 }
 
-ReturnValue_t GomspaceDeviceHandler::generateResetWatchdogCmd() {
+ReturnValue_t GomspaceDeviceHandler::handleAction(GndwdtResetAction* action) {
   WatchdogResetCommand watchdogResetCommand;
   size_t cspPacketLen = 0;
   uint8_t* buffer = cspPacket;
@@ -415,9 +384,9 @@ ReturnValue_t GomspaceDeviceHandler::generateResetWatchdogCmd() {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t GomspaceDeviceHandler::generateRequestFullHkTableCmd(uint16_t hkTableReplySize) {
+ReturnValue_t GomspaceDeviceHandler::handleAction(RequestHkTableAction* action) {
   uint16_t querySize = hkTableReplySize;
-  uint8_t tableId = HK_TABLE_ID;
+  uint8_t tableId = static_cast<uint8_t>(ParamGetAction::TableId::HK_TABLE_ID);
   RequestFullTableCommand requestFullTableCommand(querySize, tableId);
 
   size_t cspPacketLen = 0;

mission/devices/GomspaceDeviceHandler.h

@@ -4,6 +4,7 @@
 #include <mission/devices/devicedefinitions/GomSpacePackets.h>
 
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
+#include "mission/devices/devicedefinitions/GomspaceActions.h"
 #include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
 #include "returnvalues/classIds.h"
 
@@ -48,12 +49,43 @@ class GomspaceDeviceHandler : public DeviceHandlerBase {
    */
   void setModeNormal();
 
+  /**
+   * @brief	Function to generate the ping command for the ComIF.
+   */
+  ReturnValue_t handleAction(PingAction *action);
+
+  /**
+   * @brief	Function to generate the command to reboot a gomspace device
+   * 			via the ComIF.
+   */
+  ReturnValue_t handleAction(RebootAction *action);
+
+  /**
+   * @brief	Function to generate the command to force a ground watchdog
+   * 			reset in a gomspace device.
+   */
+  ReturnValue_t handleAction(GndwdtResetAction *action);
+
+  /**
+   * @brief	Function to generate the command to get a parameter from a
+   * 			gomspace device. Command will be sent to the ComIF over the
+   * 			rawPacket buffer.
+   */
+  ReturnValue_t handleAction(ParamGetAction *action);
+
+  /**
+   * @brief	Function to generate the command to set a parameter. Command
+   * 			will be sent to the ComIF over the rawPacket buffer.
+   */
+  ReturnValue_t handleAction(ParamSetAction *action);
+  ReturnValue_t handleAction(RequestHkTableAction *action);
+  ReturnValue_t handleAction(PrintSwitchVIAction *action);
+  ReturnValue_t handleAction(PrintLatchupsAction *action);
+
  protected:
   static const uint8_t MAX_PACKET_LEN = 36;
   static const uint8_t PARAM_SET_OK = 1;
   static const uint8_t PING_REPLY_SIZE = 2;
-  static const uint8_t CONFIG_TABLE_ID = 1;
-  static const uint8_t HK_TABLE_ID = 4;
 
   uint8_t rememberRequestedSize = 0;
   uint8_t rememberCommandId = GOMSPACE::NONE;
@@ -67,28 +99,31 @@ class GomspaceDeviceHandler : public DeviceHandlerBase {
 
   LocalPoolDataSetBase *hkTableDataset = nullptr;
 
+  PingAction pingAction = PingAction(this);
+  RebootAction rebootAction = RebootAction(this);
+  GndwdtResetAction gndwdtResetAction = GndwdtResetAction(this);
+  ParamGetAction paramGetAction = ParamGetAction(this);
+  ParamSetAction paramSetAction = ParamSetAction(this);
+  RequestHkTableAction requestHkTableAction = RequestHkTableAction(this);
+  PrintSwitchVIAction printSwitchVIAction = PrintSwitchVIAction(this);
+  PrintLatchupsAction printLatchupsAction = PrintLatchupsAction(this);
+
   void doStartUp() override;
   void doShutDown() override;
   virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
   ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
   virtual void fillCommandAndReplyMap() override;
-  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
-                                        size_t commandDataLen) override;
   ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize, DeviceCommandId_t *foundId,
                              size_t *foundLen) override;
   ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
   void setNormalDatapoolEntriesInvalid() override;
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
-  /**
-   * @brief   The command to generate a request to receive the full housekeeping table is device
-   *          specific. Thus the child has to build this command.
-   */
-  virtual ReturnValue_t generateRequestFullHkTableCmd(uint16_t hkTableSize);
 
   /**
    * This command handles printing the HK table to the console. This is useful for debugging
    * purposes
    * @return
+   * TODO replace by overriding the handleAction()?
    */
   virtual ReturnValue_t printStatus(DeviceCommandId_t cmd);
 
@@ -117,46 +152,18 @@ class GomspaceDeviceHandler : public DeviceHandlerBase {
                                   std::array<uint8_t, PDU::CHANNELS_LEN> initOutEnb);
 
  private:
-  SetParamMessageUnpacker setParamCacher;
-  /**
-   * @brief	Function to generate the command to set a parameter. Command
-   * 			will be sent to the ComIF over the rawPacket buffer.
-   */
-  ReturnValue_t generateSetParamCommand(const uint8_t *commandData, size_t commandDataLen);
+  SetParamMessageCache setParamCacher;
 
   /**
-   * Callback is called on a parameter set command. It is called before executing it and after
+   * Callback is called on a parameter set command. It is called before executing it and
    * after successful execution
    * @param unpacker Passed before
    * @param beforeSet False for callback before execution, true if called after successful
    *   execution
    * @return
    */
-  virtual ReturnValue_t setParamCallback(SetParamMessageUnpacker &unpacker, bool afterExecution);
-
-  /**
-   * @brief	Function to generate the command to get a parameter from a
-   * 			gomspace device. Command will be sent to the ComIF over the
-   * 			rawPacket buffer.
-   */
-  ReturnValue_t generateGetParamCommand(const uint8_t *commandData, size_t commandDataLen);
-
-  /**
-   * @brief	Function to generate the ping command for the ComIF.
-   */
-  ReturnValue_t generatePingCommand(const uint8_t *commandData, size_t commandDataLen);
-
-  /**
-   * @brief	Function to generate the command to reboot a gomspace device
-   * 			via the ComIF.
-   */
-  void generateRebootCommand();
-
-  /**
-   * @brief	Function to generate the command to force a ground watchdog
-   * 			reset in a gomspace device.
-   */
-  ReturnValue_t generateResetWatchdogCmd();
+  virtual ReturnValue_t setParamCallback(uint16_t address, uint32_t value, uint8_t valueBytes,
+                                         bool afterExecution);
 };
 
 #endif /* MISSION_DEVICES_GOMSPACEDEVICEHANDLER_H_ */

mission/devices/HeaterHandler.cpp

@@ -104,39 +104,21 @@ void HeaterHandler::readCommandQueue() {
   } while (result == RETURN_OK);
 }
 
-ReturnValue_t HeaterHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                           const uint8_t* data, size_t size) {
-  if (data == nullptr or size < 3) {
-    return HasActionsIF::INVALID_PARAMETERS;
-  }
-  if (actionId != SWITCH_HEATER) {
-    return COMMAND_NOT_SUPPORTED;
-  }
-  auto switchNr = data[0];
-  if (switchNr > 7) {
-    return HasActionsIF::INVALID_PARAMETERS;
-  }
-  auto& heater = heaterVec.at(switchNr);
+ReturnValue_t HeaterHandler::executeAction(Action* action) { return action->handle(); }
 
-  auto actionRaw = data[1];
-  if (actionRaw != 0 and actionRaw != 1) {
-    return HasActionsIF::INVALID_PARAMETERS;
-  }
-  auto action = static_cast<SwitchAction>(data[1]);
+ReturnValue_t HeaterHandler::handleAction(SetHeaterAction* heaterAction) {
+  auto& heater = heaterVec.at(heaterAction->switchNr);
+  auto action = heaterAction->switchAction.value;
   // Always accepts OFF commands
-  if (action == SwitchAction::SET_SWITCH_ON) {
+  if (action == SetHeaterAction::SwitchAction::SET_SWITCH_ON) {
     HasHealthIF::HealthState health = heater.healthDevice->getHealth();
     if (health == HasHealthIF::FAULTY or health == HasHealthIF::PERMANENT_FAULTY or
         health == HasHealthIF::NEEDS_RECOVERY) {
       return HasHealthIF::OBJECT_NOT_HEALTHY;
     }
-    CmdSourceParam cmdSource = CmdSourceParam::EXTERNAL;
-    uint8_t cmdSourceRaw = data[2];
-    if (cmdSourceRaw > 1) {
-      return HasActionsIF::INVALID_PARAMETERS;
-    }
-    cmdSource = static_cast<CmdSourceParam>(data[2]);
-    if (health == HasHealthIF::EXTERNAL_CONTROL and cmdSource == CmdSourceParam::INTERNAL) {
+    auto cmdSource = heaterAction->cmdSource.value;
+    if (health == HasHealthIF::EXTERNAL_CONTROL and
+        cmdSource == SetHeaterAction::CmdSourceParam::INTERNAL) {
       return HasHealthIF::IS_EXTERNALLY_CONTROLLED;
     }
   }
@@ -146,7 +128,7 @@ ReturnValue_t HeaterHandler::executeAction(ActionId_t actionId, MessageQueueId_t
   }
   heater.action = action;
   heater.cmdActive = true;
-  heater.replyQueue = commandedBy;
+  heater.replyQueue = heaterAction->commandedBy;
   return RETURN_OK;
 }
 
@@ -158,13 +140,13 @@ ReturnValue_t HeaterHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t o
   switch (onOff) {
     case PowerSwitchIF::SWITCH_ON:
       commandData[0] = switchNr;
-      commandData[1] = SET_SWITCH_ON;
-      commandData[2] = CmdSourceParam::INTERNAL;
+      commandData[1] = static_cast<uint8_t>(SetHeaterAction::SwitchAction::SET_SWITCH_ON);
+      commandData[2] = static_cast<uint8_t>(SetHeaterAction::CmdSourceParam::INTERNAL);
       break;
     case PowerSwitchIF::SWITCH_OFF:
       commandData[0] = switchNr;
-      commandData[1] = SET_SWITCH_OFF;
-      commandData[2] = CmdSourceParam::INTERNAL;
+      commandData[1] = static_cast<uint8_t>(SetHeaterAction::SwitchAction::SET_SWITCH_OFF);
+      commandData[2] = static_cast<uint8_t>(SetHeaterAction::CmdSourceParam::INTERNAL);
       break;
     default:
       sif::error << "HeaterHandler::sendSwitchCommand: Invalid switch request" << std::endl;
@@ -174,7 +156,8 @@ ReturnValue_t HeaterHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t o
   result = ipcStore->addData(&storeAddress, commandData, sizeof(commandData));
   if (result == RETURN_OK) {
     CommandMessage message;
-    ActionMessage::setCommand(&message, SWITCH_HEATER, storeAddress);
+    ActionMessage::setCommand(&message, static_cast<ActionId_t>(HeaterCommands::SWITCH_HEATER),
+                              storeAddress);
     /* Send heater command to own command queue */
     result = commandQueue->sendMessage(commandQueue->getId(), &message, 0);
     if (result != RETURN_OK) {
@@ -193,7 +176,7 @@ void HeaterHandler::handleSwitchHandling() {
       // will shut down the heater
       if (health == HasHealthIF::FAULTY or health == HasHealthIF::PERMANENT_FAULTY) {
         heaterVec[idx].cmdActive = true;
-        heaterVec[idx].action = SET_SWITCH_OFF;
+        heaterVec[idx].action = SetHeaterAction::SwitchAction::SET_SWITCH_OFF;
         triggerEvent(FAULTY_HEATER_WAS_ON, idx, 0);
         handleSwitchOffCommand(static_cast<heater::Switchers>(idx));
         continue;
@@ -201,10 +184,10 @@ void HeaterHandler::handleSwitchHandling() {
     }
     if (heaterVec[idx].cmdActive) {
       switch (heaterVec[idx].action) {
-        case SET_SWITCH_ON:
+        case SetHeaterAction::SwitchAction::SET_SWITCH_ON:
           handleSwitchOnCommand(static_cast<heater::Switchers>(idx));
           break;
-        case SET_SWITCH_OFF:
+        case SetHeaterAction::SwitchAction::SET_SWITCH_OFF:
           handleSwitchOffCommand(static_cast<heater::Switchers>(idx));
           break;
         default:
@@ -228,7 +211,8 @@ void HeaterHandler::handleSwitchOnCommand(heater::Switchers heaterIdx) {
     heater.cmdActive = false;
     heater.waitMainSwitchOn = false;
     if (heater.replyQueue != commandQueue->getId()) {
-      actionHelper.finish(false, heater.replyQueue, heater.action, MAIN_SWITCH_SET_TIMEOUT);
+      actionHelper.finish(false, heater.replyQueue, static_cast<ActionId_t>(heater.action),
+                          MAIN_SWITCH_SET_TIMEOUT);
     }
     return;
   }
@@ -254,9 +238,11 @@ void HeaterHandler::handleSwitchOnCommand(heater::Switchers heaterIdx) {
     // HeaterHandler itself
     if (heater.replyQueue != commandQueue->getId()) {
       if (result == RETURN_OK) {
-        actionHelper.finish(true, heater.replyQueue, heater.action, result);
+        actionHelper.finish(true, heater.replyQueue, static_cast<ActionId_t>(heater.action),
+                            result);
       } else {
-        actionHelper.finish(false, heater.replyQueue, heater.action, result);
+        actionHelper.finish(false, heater.replyQueue, static_cast<ActionId_t>(heater.action),
+                            result);
       }
     }
     heater.cmdActive = false;
@@ -272,7 +258,8 @@ void HeaterHandler::handleSwitchOnCommand(heater::Switchers heaterIdx) {
     sif::debug << "HeaterHandler::handleSwitchHandling: Failed to get state of"
                << " main line switch" << std::endl;
     if (heater.replyQueue != commandQueue->getId()) {
-      actionHelper.finish(false, heater.replyQueue, heater.action, mainSwitchState);
+      actionHelper.finish(false, heater.replyQueue, static_cast<ActionId_t>(heater.action),
+                          mainSwitchState);
     }
     heater.cmdActive = false;
   }
@@ -308,9 +295,9 @@ void HeaterHandler::handleSwitchOffCommand(heater::Switchers heaterIdx) {
   if (heater.replyQueue != NO_COMMANDER) {
     // Report back switch command reply if necessary
     if (result == HasReturnvaluesIF::RETURN_OK) {
-      actionHelper.finish(true, heater.replyQueue, heater.action, result);
+      actionHelper.finish(true, heater.replyQueue, static_cast<ActionId_t>(heater.action), result);
     } else {
-      actionHelper.finish(false, heater.replyQueue, heater.action, result);
+      actionHelper.finish(false, heater.replyQueue, static_cast<ActionId_t>(heater.action), result);
     }
   }
   heater.cmdActive = false;
@@ -333,6 +320,8 @@ bool HeaterHandler::allSwitchesOff() {
 
 MessageQueueId_t HeaterHandler::getCommandQueue() const { return commandQueue->getId(); }
 
+ActionHelper* HeaterHandler::getActionHelper() { return &actionHelper; }
+
 ReturnValue_t HeaterHandler::sendFuseOnCommand(uint8_t fuseNr) { return RETURN_OK; }
 
 ReturnValue_t HeaterHandler::getSwitchState(uint8_t switchNr) const {

mission/devices/HeaterHandler.h

@@ -17,6 +17,7 @@
 #include <array>
 #include <vector>
 
+#include "devicedefinitions/HeaterDefinitions.h"
 #include "devices/heaterSwitcherList.h"
 
 class PowerSwitchIF;
@@ -47,11 +48,6 @@ class HeaterHandler : public ExecutableObjectIF,
   static const ReturnValue_t MAIN_SWITCH_SET_TIMEOUT = MAKE_RETURN_CODE(0xA4);
   static const ReturnValue_t COMMAND_ALREADY_WAITING = MAKE_RETURN_CODE(0xA5);
 
-  enum CmdSourceParam : uint8_t { INTERNAL = 0, EXTERNAL = 1 };
-
-  /** Device command IDs */
-  static const DeviceCommandId_t SWITCH_HEATER = 0x0;
-
   HeaterHandler(object_id_t setObjectId, GpioIF* gpioInterface_, HeaterHelper helper,
                 PowerSwitchIF* mainLineSwitcherObjectId, power::Switch_t mainLineSwitch);
 
@@ -70,8 +66,10 @@ class HeaterHandler : public ExecutableObjectIF,
   uint32_t getSwitchDelayMs(void) const override;
 
   MessageQueueId_t getCommandQueue() const override;
-  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                              const uint8_t* data, size_t size) override;
+  ActionHelper* getActionHelper() override;
+  ReturnValue_t executeAction(Action* action) override;
+  ReturnValue_t handleAction(SetHeaterAction* heaterAction);
+
   ReturnValue_t initialize() override;
 
  private:
@@ -89,7 +87,6 @@ class HeaterHandler : public ExecutableObjectIF,
   static const MessageQueueId_t NO_COMMANDER = 0;
 
   enum SwitchState : bool { ON = true, OFF = false };
-  enum SwitchAction : uint8_t { SET_SWITCH_OFF, SET_SWITCH_ON, NONE };
 
   /**
    * @brief   Struct holding information about a heater command to execute.
@@ -106,7 +103,7 @@ class HeaterHandler : public ExecutableObjectIF,
         : healthDevice(pair.first), gpioId(pair.second), switchState(initState) {}
     HealthDevice* healthDevice = nullptr;
     gpioId_t gpioId = gpio::NO_GPIO;
-    SwitchAction action = SwitchAction::NONE;
+    SetHeaterAction::SwitchAction action = SetHeaterAction::SwitchAction::NONE;
     MessageQueueId_t replyQueue = MessageQueueIF::NO_QUEUE;
     bool cmdActive = false;
     SwitchState switchState = SwitchState::OFF;
@@ -140,6 +137,8 @@ class HeaterHandler : public ExecutableObjectIF,
 
   ActionHelper actionHelper;
 
+  SetHeaterAction setHeaterAction = SetHeaterAction(this);
+
   StorageManagerIF* ipcStore = nullptr;
 
   void readCommandQueue();

mission/devices/IMTQHandler.cpp

@@ -331,9 +331,7 @@ ReturnValue_t IMTQHandler::initializeLocalDataPool(localpool::DataPool& localDat
   localDataPoolMap.emplace(IMTQ::MCU_TEMPERATURE, new PoolEntry<int16_t>({0}));
 
   /** Entries of calibrated MTM measurement dataset */
-  localDataPoolMap.emplace(IMTQ::MTM_CAL_X, new PoolEntry<int32_t>({0}));
-  localDataPoolMap.emplace(IMTQ::MTM_CAL_Y, new PoolEntry<int32_t>({0}));
-  localDataPoolMap.emplace(IMTQ::MTM_CAL_Z, new PoolEntry<int32_t>({0}));
+  localDataPoolMap.emplace(IMTQ::MGM_CAL_NT, &mgmCalEntry);
   localDataPoolMap.emplace(IMTQ::ACTUATION_CAL_STATUS, new PoolEntry<uint8_t>({0}));
 
   /** Entries of raw MTM measurement dataset */
@@ -749,14 +747,15 @@ void IMTQHandler::handleGetCommandedDipoleReply(const uint8_t* packet) {
 
 void IMTQHandler::fillCalibratedMtmDataset(const uint8_t* packet) {
   PoolReadGuard rg(&calMtmMeasurementSet);
+  calMtmMeasurementSet.setValidity(true, true);
   int8_t offset = 2;
-  calMtmMeasurementSet.mtmXnT = *(packet + offset + 3) << 24 | *(packet + offset + 2) << 16 |
+  calMtmMeasurementSet.mgmXyz[0] = *(packet + offset + 3) << 24 | *(packet + offset + 2) << 16 |
                                 *(packet + offset + 1) << 8 | *(packet + offset);
   offset += 4;
-  calMtmMeasurementSet.mtmYnT = *(packet + offset + 3) << 24 | *(packet + offset + 2) << 16 |
+  calMtmMeasurementSet.mgmXyz[1] = *(packet + offset + 3) << 24 | *(packet + offset + 2) << 16 |
                                 *(packet + offset + 1) << 8 | *(packet + offset);
   offset += 4;
-  calMtmMeasurementSet.mtmZnT = *(packet + offset + 3) << 24 | *(packet + offset + 2) << 16 |
+  calMtmMeasurementSet.mgmXyz[2] = *(packet + offset + 3) << 24 | *(packet + offset + 2) << 16 |
                                 *(packet + offset + 1) << 8 | *(packet + offset);
   offset += 4;
   calMtmMeasurementSet.coilActuationStatus = (*(packet + offset + 3) << 24) |
@@ -764,11 +763,11 @@ void IMTQHandler::fillCalibratedMtmDataset(const uint8_t* packet) {
                                              (*(packet + offset + 1) << 8) | (*(packet + offset));
   if (debugMode) {
 #if OBSW_VERBOSE_LEVEL >= 1
-    sif::info << "IMTQ calibrated MTM measurement X: " << calMtmMeasurementSet.mtmXnT << " nT"
+    sif::info << "IMTQ calibrated MTM measurement X: " << calMtmMeasurementSet.mgmXyz[0] << " nT"
               << std::endl;
-    sif::info << "IMTQ calibrated MTM measurement Y: " << calMtmMeasurementSet.mtmYnT << " nT"
+    sif::info << "IMTQ calibrated MTM measurement Y: " << calMtmMeasurementSet.mgmXyz[1] << " nT"
               << std::endl;
-    sif::info << "IMTQ calibrated MTM measurement Z: " << calMtmMeasurementSet.mtmZnT << " nT"
+    sif::info << "IMTQ calibrated MTM measurement Z: " << calMtmMeasurementSet.mgmXyz[2] << " nT"
               << std::endl;
     sif::info << "IMTQ coil actuation status during MTM measurement: "
               << (unsigned int)calMtmMeasurementSet.coilActuationStatus.value << std::endl;

mission/devices/IMTQHandler.h

@@ -99,6 +99,8 @@ class IMTQHandler : public DeviceHandlerBase {
   IMTQ::PosZSelfTestSet posZselfTestDataset;
   IMTQ::NegZSelfTestSet negZselfTestDataset;
 
+  PoolEntry<int32_t> mgmCalEntry = PoolEntry<int32_t>(3);
+
   power::Switch_t switcher = power::NO_SWITCH;
 
   uint8_t commandBuffer[IMTQ::MAX_COMMAND_SIZE];

mission/devices/P60DockHandler.cpp

@@ -16,7 +16,7 @@ P60DockHandler::~P60DockHandler() {}
 
 ReturnValue_t P60DockHandler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
   *id = GOMSPACE::REQUEST_HK_TABLE;
-  return buildCommandFromCommand(*id, NULL, 0);
+  return requestHkTableAction.handle();
 }
 
 void P60DockHandler::letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *packet) {

mission/devices/PDU1Handler.cpp

@@ -16,7 +16,7 @@ PDU1Handler::~PDU1Handler() {}
 
 ReturnValue_t PDU1Handler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
   *id = GOMSPACE::REQUEST_HK_TABLE;
-  return buildCommandFromCommand(*id, NULL, 0);
+  return requestHkTableAction.handle();
 }
 
 void PDU1Handler::letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *packet) {
@@ -29,49 +29,48 @@ void PDU1Handler::assignChannelHookFunction(GOMSPACE::ChannelSwitchHook hook, vo
   this->hookArgs = args;
 }
 
-ReturnValue_t PDU1Handler::setParamCallback(SetParamMessageUnpacker &unpacker,
-                                            bool afterExecution) {
+ReturnValue_t PDU1Handler::setParamCallback(uint16_t address, uint32_t value, uint8_t valueBytes, bool afterExecution) {
   using namespace PDU1;
   GOMSPACE::Pdu pdu = GOMSPACE::Pdu::PDU1;
   if (not afterExecution) {
     return HasReturnvaluesIF::RETURN_OK;
   }
-  if (channelSwitchHook != nullptr and unpacker.getParameterSize() == 1) {
-    switch (unpacker.getAddress()) {
+  if (channelSwitchHook != nullptr and valueBytes == 1) {
+    switch (address) {
       case (CONFIG_ADDRESS_OUT_EN_TCS_BOARD_3V3): {
-        channelSwitchHook(pdu, 0, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 0, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_SYRLINKS): {
-        channelSwitchHook(pdu, 1, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 1, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_STAR_TRACKER): {
-        channelSwitchHook(pdu, 2, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 2, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_MGT): {
-        channelSwitchHook(pdu, 3, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 3, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_SUS_NOMINAL): {
-        channelSwitchHook(pdu, 4, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 4, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_SOLAR_CELL_EXP): {
-        channelSwitchHook(pdu, 5, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 5, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_PLOC): {
-        channelSwitchHook(pdu, 6, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 6, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_A): {
-        channelSwitchHook(pdu, 7, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 7, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_CHANNEL8): {
-        channelSwitchHook(pdu, 8, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 8, value, hookArgs);
         break;
       }
     }

mission/devices/PDU1Handler.h

@@ -38,7 +38,7 @@ class PDU1Handler : public GomspaceDeviceHandler {
   virtual void letChildHandleHkReply(DeviceCommandId_t id, const uint8_t* packet) override;
   ReturnValue_t printStatus(DeviceCommandId_t cmd) override;
   LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
-  ReturnValue_t setParamCallback(SetParamMessageUnpacker& unpacker, bool afterExectuion) override;
+  ReturnValue_t setParamCallback(uint16_t address, uint32_t value, uint8_t valueBytes, bool afterExecution) override;
 
  private:
   static constexpr uint8_t MAX_CHANNEL_STR_WIDTH = 24;

mission/devices/PDU2Handler.cpp

@@ -16,7 +16,7 @@ PDU2Handler::~PDU2Handler() {}
 
 ReturnValue_t PDU2Handler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
   *id = GOMSPACE::REQUEST_HK_TABLE;
-  return buildCommandFromCommand(*id, NULL, 0);
+  return requestHkTableAction.handle();
 }
 
 void PDU2Handler::letChildHandleHkReply(DeviceCommandId_t id, const uint8_t *packet) {
@@ -127,49 +127,48 @@ void PDU2Handler::printHkTableLatchups() {
   printerHelper("Payload Camera", Channels::PAYLOAD_CAMERA);
 }
 
-ReturnValue_t PDU2Handler::setParamCallback(SetParamMessageUnpacker &unpacker,
-                                            bool afterExecution) {
+ReturnValue_t PDU2Handler::setParamCallback(uint16_t address, uint32_t value, uint8_t valueBytes, bool afterExecution) {
   using namespace PDU2;
   GOMSPACE::Pdu pdu = GOMSPACE::Pdu::PDU2;
   if (not afterExecution) {
     return HasReturnvaluesIF::RETURN_OK;
   }
-  if (channelSwitchHook != nullptr and unpacker.getParameterSize() == 1) {
-    switch (unpacker.getAddress()) {
+  if (channelSwitchHook != nullptr and valueBytes == 1) {
+    switch (address) {
       case (CONFIG_ADDRESS_OUT_EN_Q7S): {
-        channelSwitchHook(pdu, 0, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 0, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH1): {
-        channelSwitchHook(pdu, 1, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 1, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_RW): {
-        channelSwitchHook(pdu, 2, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 2, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_TCS_BOARD_HEATER_IN): {
-        channelSwitchHook(pdu, 3, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 3, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_SUS_REDUNDANT): {
-        channelSwitchHook(pdu, 4, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 4, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_DEPLOYMENT_MECHANISM): {
-        channelSwitchHook(pdu, 5, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 5, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_PAYLOAD_PCDU_CH6): {
-        channelSwitchHook(pdu, 6, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 6, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_ACS_BOARD_SIDE_B): {
-        channelSwitchHook(pdu, 7, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 7, value, hookArgs);
         break;
       }
       case (CONFIG_ADDRESS_OUT_EN_PAYLOAD_CAMERA): {
-        channelSwitchHook(pdu, 8, unpacker.getParameter()[0], hookArgs);
+        channelSwitchHook(pdu, 8, value, hookArgs);
         break;
       }
     }

mission/devices/PDU2Handler.h

@@ -36,7 +36,7 @@ class PDU2Handler : public GomspaceDeviceHandler {
   virtual ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
   virtual void letChildHandleHkReply(DeviceCommandId_t id, const uint8_t* packet) override;
   ReturnValue_t printStatus(DeviceCommandId_t cmd) override;
-  ReturnValue_t setParamCallback(SetParamMessageUnpacker& unpacker, bool afterExecution) override;
+  ReturnValue_t setParamCallback(uint16_t address, uint32_t value, uint8_t valueBytes, bool afterExecution) override;
   LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
 
  private:

mission/devices/SolarArrayDeploymentHandler.cpp

@@ -111,8 +111,10 @@ void SolarArrayDeploymentHandler::performWaitOn8VActions() {
   } else {
     if (mainSwitchCountdown.hasTimedOut()) {
       triggerEvent(MAIN_SWITCH_ON_TIMEOUT);
-      actionHelper.finish(false, rememberCommanderId, DEPLOY_SOLAR_ARRAYS,
-                          MAIN_SWITCH_TIMEOUT_FAILURE);
+      actionHelper.finish(
+          false, rememberCommanderId,
+          static_cast<DeviceCommandId_t>(SolarArrayDeploymentCommands::DEPLOY_SOLAR_ARRAYS),
+          MAIN_SWITCH_TIMEOUT_FAILURE);
       stateMachine = WAIT_ON_DELOYMENT_COMMAND;
     }
   }
@@ -129,7 +131,10 @@ void SolarArrayDeploymentHandler::switchDeploymentTransistors() {
      * the deployment sequence. */
     stateMachine = WAIT_ON_DELOYMENT_COMMAND;
     triggerEvent(DEPL_SA1_GPIO_SWTICH_ON_FAILED);
-    actionHelper.finish(false, rememberCommanderId, DEPLOY_SOLAR_ARRAYS, SWITCHING_DEPL_SA2_FAILED);
+    actionHelper.finish(
+        false, rememberCommanderId,
+        static_cast<DeviceCommandId_t>(SolarArrayDeploymentCommands::DEPLOY_SOLAR_ARRAYS),
+        SWITCHING_DEPL_SA1_FAILED);
     mainLineSwitcher->sendSwitchCommand(mainLineSwitch, PowerSwitchIF::SWITCH_OFF);
   }
   result = gpioInterface->pullHigh(deplSA2);
@@ -139,7 +144,10 @@ void SolarArrayDeploymentHandler::switchDeploymentTransistors() {
                << std::endl;
     stateMachine = WAIT_ON_DELOYMENT_COMMAND;
     triggerEvent(DEPL_SA2_GPIO_SWTICH_ON_FAILED);
-    actionHelper.finish(false, rememberCommanderId, DEPLOY_SOLAR_ARRAYS, SWITCHING_DEPL_SA2_FAILED);
+    actionHelper.finish(
+        false, rememberCommanderId,
+        static_cast<DeviceCommandId_t>(SolarArrayDeploymentCommands::DEPLOY_SOLAR_ARRAYS),
+        SWITCHING_DEPL_SA2_FAILED);
     mainLineSwitcher->sendSwitchCommand(mainLineSwitch, PowerSwitchIF::SWITCH_OFF);
   }
   deploymentCountdown.setTimeout(burnTimeMs);
@@ -149,7 +157,10 @@ void SolarArrayDeploymentHandler::switchDeploymentTransistors() {
 void SolarArrayDeploymentHandler::handleDeploymentFinish() {
   ReturnValue_t result = RETURN_OK;
   if (deploymentCountdown.hasTimedOut()) {
-    actionHelper.finish(true, rememberCommanderId, DEPLOY_SOLAR_ARRAYS, RETURN_OK);
+    actionHelper.finish(
+        true, rememberCommanderId,
+        static_cast<DeviceCommandId_t>(SolarArrayDeploymentCommands::DEPLOY_SOLAR_ARRAYS),
+        RETURN_OK);
     result = gpioInterface->pullLow(deplSA1);
     if (result != RETURN_OK) {
       sif::debug << "SolarArrayDeploymentHandler::handleStateMachine: Failed to pull solar"
@@ -181,27 +192,24 @@ void SolarArrayDeploymentHandler::readCommandQueue() {
   }
 }
 
-ReturnValue_t SolarArrayDeploymentHandler::executeAction(ActionId_t actionId,
-                                                         MessageQueueId_t commandedBy,
-                                                         const uint8_t* data, size_t size) {
-  ReturnValue_t result;
+ReturnValue_t SolarArrayDeploymentHandler::executeAction(Action* action) {
   if (stateMachine != WAIT_ON_DELOYMENT_COMMAND) {
     sif::error << "SolarArrayDeploymentHandler::executeAction: Received command while not in"
                << "waiting-on-command-state" << std::endl;
     return DEPLOYMENT_ALREADY_EXECUTING;
   }
-  if (actionId != DEPLOY_SOLAR_ARRAYS) {
-    sif::error << "SolarArrayDeploymentHandler::executeAction: Received invalid command"
-               << std::endl;
-    result = COMMAND_NOT_SUPPORTED;
-  } else {
-    stateMachine = SWITCH_8V_ON;
-    rememberCommanderId = commandedBy;
-    result = RETURN_OK;
-  }
-  return result;
+  // delegates to SolarArrayDeploymentHandler::handleAction()
+  return action->handle();
+}
+
+ReturnValue_t SolarArrayDeploymentHandler::handleAction(SolarArrayDeploymentAction* action) {
+  stateMachine = SWITCH_8V_ON;
+  rememberCommanderId = action->commandedBy;
+  return RETURN_OK;
 }
 
 MessageQueueId_t SolarArrayDeploymentHandler::getCommandQueue() const {
   return commandQueue->getId();
 }
+
+ActionHelper* SolarArrayDeploymentHandler::getActionHelper() { return &actionHelper; }

mission/devices/SolarArrayDeploymentHandler.h

@@ -14,6 +14,8 @@
 
 #include <unordered_map>
 
+#include "devicedefinitions/SolarArrayDeploymentDefinitions.h"
+
 /**
  * @brief	This class is used to control the solar array deployment.
  *
@@ -24,8 +26,6 @@ class SolarArrayDeploymentHandler : public ExecutableObjectIF,
                                     public HasReturnvaluesIF,
                                     public HasActionsIF {
  public:
-  static const DeviceCommandId_t DEPLOY_SOLAR_ARRAYS = 0x5;
-
   /**
    * @brief constructor
    *
@@ -51,8 +51,9 @@ class SolarArrayDeploymentHandler : public ExecutableObjectIF,
   virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
 
   virtual MessageQueueId_t getCommandQueue() const override;
-  virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                      const uint8_t* data, size_t size) override;
+  virtual ActionHelper* getActionHelper() override;
+  virtual ReturnValue_t executeAction(Action* action) override;
+  ReturnValue_t handleAction(SolarArrayDeploymentAction* action);
   virtual ReturnValue_t initialize() override;
 
  private:
@@ -129,6 +130,8 @@ class SolarArrayDeploymentHandler : public ExecutableObjectIF,
 
   ActionHelper actionHelper;
 
+  SolarArrayDeploymentAction deploymentAction = SolarArrayDeploymentAction(this);
+
   void readCommandQueue();
 
   /**

mission/devices/devicedefinitions/GomSpacePackets.h

@@ -332,14 +332,37 @@ class Pdu2FullTableReply : public SerialLinkedListAdapter<SerializeIF> {
   LinkedElement<SerializeIF> dataset;
 };
 
+class SetParamMessageCache {
+ public:
+  SetParamMessageCache() : address(0), parameter(0), parameterSize(1) {}
+
+  void set(uint16_t address, uint32_t parameter, uint8_t parameterSize) {
+    this->address = address;
+    this->parameter = parameter;
+    this->parameterSize = parameterSize;
+  }
+
+  uint16_t getAddress() { return address; }
+
+  uint32_t getParameter() { return parameter; }
+
+  uint8_t getParameterSize() { return parameterSize; }
+
+ private:
+  uint16_t address;
+  uint32_t parameter;
+  uint8_t parameterSize;
+};
+
 /**
  * @brief	This class helps to unpack information from an action message
  * 			  to set a parameter in gomspace devices. The action message can be
  * 			  for example received from the PUS Service 8.
  */
+/*
 class SetParamMessageUnpacker : public SerialLinkedListAdapter<SerializeIF> {
  public:
-  /* Largest parameter is a uint32_t */
+  // Largest parameter is a uint32_t
   static const uint32_t MAX_SIZE = 4;
 
   SetParamMessageUnpacker() { setLinks(); }
@@ -358,7 +381,7 @@ class SetParamMessageUnpacker : public SerialLinkedListAdapter<SerializeIF> {
   SetParamMessageUnpacker(const SetParamMessageUnpacker &message);
   SerializeElement<uint16_t> address;
   SerializeElement<SerialFixedArrayListAdapter<uint8_t, MAX_SIZE, uint8_t>> parameter;
-};
+};*/
 
 /**
  * @brief   This class generates a message which can be sent to the GomspaceDeviceHandler to
@@ -405,6 +428,7 @@ class GomspaceSetParamMessage : public SerialLinkedListAdapter<SerializeIF> {
  * 			to get a parameter from gomspace devices. The action message can be
  * 			for example received from the PUS Service 8.
  */
+/*
 class GetParamMessageUnpacker : public SerialLinkedListAdapter<SerializeIF> {
  public:
   GetParamMessageUnpacker() { setLinks(); }
@@ -424,8 +448,8 @@ class GetParamMessageUnpacker : public SerialLinkedListAdapter<SerializeIF> {
   }
   SerializeElement<uint8_t> tableId;
   SerializeElement<uint16_t> address;  // The memory address offset within the table
-  /* The size of the requested value (e.g. temperature is a uint16_t value) */
+  // The size of the requested value (e.g. temperature is a uint16_t value)
   SerializeElement<uint8_t> parameterSize;
-};
+};*/
 
 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_GOMSPACEPACKETS_H_ */

mission/devices/devicedefinitions/GomspaceActions.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <fsfw/action/MinMaxParameter.h>
+#include <fsfw/action/TemplateAction.h>
+
+#include "GomspaceDefinitions.h"
+
+class GomspaceDeviceHandler;
+
+class PingAction : public TemplateAction<GomspaceDeviceHandler, PingAction, GOMSPACE::GomspaceCommands> {
+ public:
+  PingAction(GomspaceDeviceHandler* owner) : TemplateAction(owner, GOMSPACE::PING) {}
+
+  // TODO array
+  Parameter<uint8_t> pingData = Parameter<uint8_t>::createParameter(this, "Ping Data");
+};
+
+class RebootAction : public TemplateAction<GomspaceDeviceHandler, RebootAction, GOMSPACE::GomspaceCommands> {
+ public:
+  RebootAction(GomspaceDeviceHandler* owner) : TemplateAction(owner, GOMSPACE::REBOOT) {}
+};
+
+class GndwdtResetAction
+    : public TemplateAction<GomspaceDeviceHandler, GndwdtResetAction, GOMSPACE::GomspaceCommands> {
+ public:
+  GndwdtResetAction(GomspaceDeviceHandler* owner)
+      : TemplateAction(owner, GOMSPACE::GNDWDT_RESET) {}
+};
+
+class ParamGetAction
+    : public TemplateAction<GomspaceDeviceHandler, ParamGetAction, GOMSPACE::GomspaceCommands> {
+ public:
+   FSFW_ENUM(ParameterByteSize, uint8_t,
+            ((ONE_BYTE, 1, "One Byte"))((TWO_BYTES, 2, "Two Bytes"))((FOUR_BYTES, 4, "Four Bytes")))
+ FSFW_ENUM(TableId, uint8_t,
+            ((CONFIG_TABLE_ID, 1, "Config Table"))((HK_TABLE_ID, 4, "Housekeeping Table")))
+  ParamGetAction(GomspaceDeviceHandler* owner)
+      : TemplateAction(owner, GOMSPACE::PARAM_GET) {}
+
+Parameter<TableId> tableId =
+      Parameter<TableId>::createParameter(this, "Table");
+Parameter<uint16_t> address = Parameter<uint16_t>::createParameter(this, "Address");
+    Parameter<ParameterByteSize> parameterSize =
+      Parameter<ParameterByteSize>::createParameter(this, "Parameter Size");  
+};
+
+class ParamSetAction
+    : public TemplateAction<GomspaceDeviceHandler, ParamSetAction, GOMSPACE::GomspaceCommands> {
+ public:
+  FSFW_ENUM(ParameterByteSize, uint8_t,
+            ((ONE_BYTE, 1, "One Byte"))((TWO_BYTES, 2, "Two Bytes"))((FOUR_BYTES, 4, "Four Bytes")))
+
+  ParamSetAction(GomspaceDeviceHandler* owner)
+      : TemplateAction(owner, GOMSPACE::PARAM_SET) {}
+
+  Parameter<uint16_t> address = Parameter<uint16_t>::createParameter(this, "Address");
+  Parameter<uint32_t> parameter = Parameter<uint32_t>::createParameter(this, "Parameter Value");
+  Parameter<ParameterByteSize> parameterSize =
+      Parameter<ParameterByteSize>::createParameter(this, "Parameter Size");
+};
+
+class RequestHkTableAction
+    : public TemplateAction<GomspaceDeviceHandler, RequestHkTableAction, GOMSPACE::GomspaceCommands> {
+ public:
+  RequestHkTableAction(GomspaceDeviceHandler* owner)
+      : TemplateAction(owner, GOMSPACE::REQUEST_HK_TABLE) {}
+};
+
+class PrintSwitchVIAction
+    : public TemplateAction<GomspaceDeviceHandler, PrintSwitchVIAction, GOMSPACE::GomspaceCommands> {
+ public:
+  PrintSwitchVIAction(GomspaceDeviceHandler* owner)
+      : TemplateAction(owner, GOMSPACE::PRINT_SWITCH_V_I) {}
+};
+
+class PrintLatchupsAction
+    : public TemplateAction<GomspaceDeviceHandler, PrintLatchupsAction, GOMSPACE::GomspaceCommands> {
+ public:
+  PrintLatchupsAction(GomspaceDeviceHandler* owner)
+      : TemplateAction(owner, GOMSPACE::PRINT_LATCHUPS) {}
+};

mission/devices/devicedefinitions/GomspaceDefinitions.h

@@ -4,6 +4,7 @@
 #include <fsfw/datapoollocal/LocalPoolVariable.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/introspection/ClasslessEnum.h>
 #include <fsfw/power/definitions.h>
 
 #include <cstdint>
@@ -12,6 +13,18 @@
 
 namespace GOMSPACE {
 
+/**
+ * Device commands are derived from the rparam.h of the gomspace lib..
+ * IDs above 50 are reserved for device specific commands.
+ */
+FSFW_CLASSLESS_ENUM(
+    GomspaceCommands, DeviceCommandId_t,
+    ((PING, 1, "Ping"))((NONE, 2, "None (used internally)"))((REBOOT, 4, "Reboot"))(
+        (GNDWDT_RESET, 9, "Reset Watchdog"))((PARAM_GET, 0, "Get Parameter"))(
+        (PARAM_SET, 255, "Set Parameter"))((REQUEST_HK_TABLE, 16, "Request Housekeeping Table"))(
+        (PRINT_SWITCH_V_I, 32, "Print switch states, voltages and currents to the console"))(
+        (PRINT_LATCHUPS, 33, "Print Latchups to the console")))
+
 enum class Pdu { PDU1, PDU2 };
 
 using ChannelSwitchHook = void (*)(Pdu pdu, uint8_t channel, bool on, void* args);
@@ -26,23 +39,6 @@ static const uint8_t REBOOT_PORT = 4;
 static const uint8_t PARAM_PORT = 7;
 static const uint8_t P60_PORT_GNDWDT_RESET = 9;
 
-/**
- * Device commands are derived from the rparam.h of the gomspace lib..
- * IDs above 50 are reserved for device specific commands.
- */
-static const DeviceCommandId_t PING = 1;               //!< [EXPORT] : [COMMAND]
-static const DeviceCommandId_t NONE = 2;               // Set when no command is pending
-static const DeviceCommandId_t REBOOT = 4;             //!< [EXPORT] : [COMMAND]
-static const DeviceCommandId_t GNDWDT_RESET = 9;       //!< [EXPORT] : [COMMAND]
-static const DeviceCommandId_t PARAM_GET = 0;          //!< [EXPORT] : [COMMAND]
-static const DeviceCommandId_t PARAM_SET = 255;        //!< [EXPORT] : [COMMAND]
-static const DeviceCommandId_t REQUEST_HK_TABLE = 16;  //!< [EXPORT] : [COMMAND]
-
-//! [EXPORT] : [COMMAND] Print switch states, voltages and currents to the console
-//! For the ACU device, only print voltages and currents of the 6 ACU channels
-static const DeviceCommandId_t PRINT_SWITCH_V_I = 32;
-static const DeviceCommandId_t PRINT_LATCHUPS = 33;
-
 }  // namespace GOMSPACE
 
 namespace P60System {

mission/devices/devicedefinitions/HeaterDefinitions.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <fsfw/action/MinMaxParameter.h>
+#include <fsfw/action/TemplateAction.h>
+#include <fsfw/introspection/Enum.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+
+class HeaterHandler;
+
+FSFW_ENUM(HeaterCommands, DeviceCommandId_t, ((SWITCH_HEATER, 0x0, "Switch Heater")))
+
+class SetHeaterAction : public TemplateAction<HeaterHandler, SetHeaterAction, HeaterCommands> {
+ public:
+  FSFW_ENUM(SwitchAction, uint8_t,
+            ((SET_SWITCH_OFF, "Set switch to Off"))((SET_SWITCH_ON, "Set switch to On")) ((NONE, "No Action")))
+  FSFW_ENUM(CmdSourceParam, uint8_t, ((INTERNAL, 0, "Internal"))((EXTERNAL, 1, "External")))
+
+  SetHeaterAction(HeaterHandler *owner) : TemplateAction(owner, HeaterCommands::SWITCH_HEATER) {}
+
+  MinMaxParameter<uint8_t> switchNr =
+      MinMaxParameter<uint8_t>::createMinMaxParameter(this, "Heater number", 0, 7);
+  Parameter<SwitchAction> switchAction =
+      Parameter<SwitchAction>::createParameter(this, "Switch Action");
+  Parameter<CmdSourceParam> cmdSource =
+      Parameter<CmdSourceParam>::createParameter(this, "Command Source");
+};

mission/devices/devicedefinitions/IMTQHandlerDefinitions.h

@@ -115,9 +115,7 @@ enum IMTQPoolIds : lp_id_t {
   COIL_Y_TEMPERATURE,
   COIL_Z_TEMPERATURE,
   MCU_TEMPERATURE,
-  MTM_CAL_X,
-  MTM_CAL_Y,
-  MTM_CAL_Z,
+  MGM_CAL_NT,
   ACTUATION_CAL_STATUS,
   MTM_RAW_X,
   MTM_RAW_Y,
@@ -408,9 +406,7 @@ class CalibratedMtmMeasurementSet : public StaticLocalDataSet<CAL_MTM_POOL_ENTRI
       : StaticLocalDataSet(sid_t(objectId, CAL_MTM_SET)) {}
 
   /** The unit of all measurements is nT */
-  lp_var_t<int32_t> mtmXnT = lp_var_t<int32_t>(sid.objectId, MTM_CAL_X, this);
-  lp_var_t<int32_t> mtmYnT = lp_var_t<int32_t>(sid.objectId, MTM_CAL_Y, this);
-  lp_var_t<int32_t> mtmZnT = lp_var_t<int32_t>(sid.objectId, MTM_CAL_Z, this);
+  lp_vec_t<int32_t, 3> mgmXyz = lp_vec_t<int32_t, 3>(sid.objectId, MGM_CAL_NT);
   /** 1 if coils were actuating during measurement otherwise 0 */
   lp_var_t<uint8_t> coilActuationStatus =
       lp_var_t<uint8_t>(sid.objectId, ACTUATION_CAL_STATUS, this);

mission/devices/devicedefinitions/SolarArrayDeploymentDefinitions.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <fsfw/action/MinMaxParameter.h>
+#include <fsfw/action/TemplateAction.h>
+#include <fsfw/introspection/Enum.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+
+class SolarArrayDeploymentHandler;
+
+FSFW_ENUM(SolarArrayDeploymentCommands, DeviceCommandId_t,((DEPLOY_SOLAR_ARRAYS, 0x05, "Deploy Solar Arrays")))
+
+class SolarArrayDeploymentAction
+    : public TemplateAction<SolarArrayDeploymentHandler, SolarArrayDeploymentAction,
+                            SolarArrayDeploymentCommands> {
+ public:
+  SolarArrayDeploymentAction(SolarArrayDeploymentHandler *owner)
+      : TemplateAction(owner, SolarArrayDeploymentCommands::DEPLOY_SOLAR_ARRAYS) {}
+};

mission/devices/max1227.cpp

@@ -3,7 +3,7 @@
 #include <cstring>
 
 void max1227::prepareExternallyClockedSingleChannelRead(uint8_t *spiBuf, uint8_t channel,
-                                                        size_t &sz) {
+                                                        uint32_t &sz) {
   spiBuf[0] = buildConvByte(ScanModes::N_ONCE, channel, false);
   spiBuf[1] = 0x00;
   spiBuf[2] = 0x00;

mission/devices/max1227.h

@@ -58,7 +58,7 @@ constexpr uint8_t buildSetupByte(ClkSel clkSel, RefSel refSel, DiffSel diffSel)
  * @param n
  * @param sz
  */
-void prepareExternallyClockedSingleChannelRead(uint8_t* spiBuf, uint8_t channel, size_t& sz);
+void prepareExternallyClockedSingleChannelRead(uint8_t* spiBuf, uint8_t channel, uint32_t& sz);
 
 /**
  * If there is a wakeup delay, there needs to be a 65 us delay between sending

mission/system/DualLaneAssemblyBase.cpp

@@ -1,6 +1,7 @@
 #include "DualLaneAssemblyBase.h"
 
 #include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
 
 #include "OBSWConfig.h"
 
@@ -92,6 +93,10 @@ ReturnValue_t DualLaneAssemblyBase::pwrStateMachineWrapper() {
   return RETURN_OK;
 }
 
+ModeDefinitionHelper DualLaneAssemblyBase::getModeDefinitionHelper() {
+  return ModeDefinitionHelper::create<DeviceHandlerIF::DeviceHandlerMode, duallane::Submodes>();
+}
+
 ReturnValue_t DualLaneAssemblyBase::isModeCombinationValid(Mode_t mode, Submode_t submode) {
   using namespace duallane;
   if (submode != A_SIDE and submode != B_SIDE and submode != DUAL_MODE) {

mission/system/DualLaneAssemblyBase.h

@@ -22,6 +22,8 @@ class DualLaneAssemblyBase : public AssemblyBase, public ConfirmsFailuresIF {
                        pcdu::Switches switch1, pcdu::Switches switch2, Event pwrSwitchTimeoutEvent,
                        Event sideSwitchNotAllowedEvent, Event transitionOtherSideFailedEvent);
 
+  ModeDefinitionHelper getModeDefinitionHelper() override;
+
  protected:
   // This helper object complete encapsulates power switching
   DualLanePowerStateMachine pwrStateMachine;

mission/system/RwAssembly.cpp

@@ -189,3 +189,7 @@ void RwAssembly::handleModeTransitionFailed(ReturnValue_t result) {
     }
   }
 }
+
+ModeDefinitionHelper RwAssembly::getModeDefinitionHelper() {
+  return ModeDefinitionHelper::create<DeviceHandlerIF::DeviceHandlerMode, HasModesIF::DefaultSubmode>();
+}

mission/system/RwAssembly.h

@@ -15,6 +15,10 @@ class RwAssembly : public AssemblyBase {
   RwAssembly(object_id_t objectId, object_id_t parentId, PowerSwitchIF* pwrSwitcher,
              power::Switch_t switcher, RwHelper helper);
 
+  ~RwAssembly() {}
+
+  ModeDefinitionHelper getModeDefinitionHelper() override;
+
  private:
   static constexpr uint8_t NUMBER_RWS = 4;
   RwHelper helper;

mission/system/TcsBoardAssembly.cpp

@@ -203,3 +203,7 @@ void TcsBoardAssembly::handleModeTransitionFailed(ReturnValue_t result) {
     triggerEvent(MODE_TRANSITION_FAILED, result);
   }
 }
+
+ModeDefinitionHelper TcsBoardAssembly::getModeDefinitionHelper(){
+  return ModeDefinitionHelper::create<DeviceHandlerIF::DeviceHandlerMode, HasModesIF::DefaultSubmode>();
+}

mission/system/TcsBoardAssembly.h

@@ -22,6 +22,8 @@ class TcsBoardAssembly : public AssemblyBase, public ConfirmsFailuresIF {
 
   ReturnValue_t initialize() override;
 
+  ModeDefinitionHelper getModeDefinitionHelper();
+
  private:
   static constexpr uint8_t NUMBER_RTDS = 16;
   PowerSwitcher switcher;

mission/system/definitions.h

@@ -2,6 +2,7 @@
 #define MISSION_SYSTEM_DEFINITIONS_H_
 
 #include <fsfw/modes/ModeMessage.h>
+#include <fsfw/introspection/ClasslessEnum.h>
 
 namespace power {
 
@@ -12,7 +13,7 @@ enum class OpCodes { NONE, TO_OFF_DONE, TO_NOT_OFF_DONE, TIMEOUT_OCCURED };
 
 namespace duallane {
 
-enum Submodes : Submode_t { A_SIDE = 0, B_SIDE = 1, DUAL_MODE = 2 };
+FSFW_CLASSLESS_ENUM(Submodes, Submode_t, ((A_SIDE, 0, "Side A")) ((B_SIDE, 1, "Side B")) ((DUAL_MODE, 2, "Dual mode")))
 
 }  // namespace duallane
 

mission/tmtc/CCSDSActions.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <fsfw/action/MinMaxParameter.h>
+#include <fsfw/action/TemplateAction.h>
+#include <fsfw/devicehandlers/DeviceHandlerIF.h>
+#include <fsfw/introspection/Enum.h>
+
+class CCSDSHandler;
+
+FSFW_ENUM(
+    CCSDSCommands, DeviceCommandId_t,
+    ((SET_LOW_RATE, 0, "Set Low rate"))((SET_HIGH_RATE, 1, "Set High Rate"))(
+        (EN_TRANSMITTER, 2, "Enable Transmitter"))((DISABLE_TRANSMITTER, 3, "Disable Transmitter"))(
+        (ARBITRARY_RATE, 4, "Set Bit Rate"))((ENABLE_TX_CLK_MANIPULATOR, 5,
+                                              "Enable Tx Clock Manipulator"))(
+        (DISABLE_TX_CLK_MANIPULATOR, 6, "Enable Tx Clock Manipulator"))(
+        (UPDATE_ON_RISING_EDGE, 7, "update data on rising edge"))((UPDATE_ON_FALLING_EDGE, 8,
+                                                                   "update data on falling edge")))
+
+class SetLowRateAction : public TemplateAction<CCSDSHandler, SetLowRateAction, CCSDSCommands> {
+ public:
+  SetLowRateAction(CCSDSHandler* owner)
+      : TemplateAction(owner, CCSDSCommands::SET_LOW_RATE) {}
+};
+class SetHighRateAction : public TemplateAction<CCSDSHandler, SetHighRateAction, CCSDSCommands> {
+ public:
+  SetHighRateAction(CCSDSHandler* owner)
+      : TemplateAction(owner, CCSDSCommands::SET_HIGH_RATE) {}
+};
+class EnTransmitterAction
+    : public TemplateAction<CCSDSHandler, EnTransmitterAction, CCSDSCommands> {
+ public:
+  EnTransmitterAction(CCSDSHandler* owner)
+      : TemplateAction(owner, CCSDSCommands::EN_TRANSMITTER) {}
+};
+class DisableTransmitterAction
+    : public TemplateAction<CCSDSHandler, DisableTransmitterAction, CCSDSCommands> {
+ public:
+  DisableTransmitterAction(CCSDSHandler* owner)
+      : TemplateAction(owner, CCSDSCommands::DISABLE_TRANSMITTER) {}
+};
+class ArbitraryRateAction
+    : public TemplateAction<CCSDSHandler, ArbitraryRateAction, CCSDSCommands> {
+ public:
+  ArbitraryRateAction(CCSDSHandler* owner)
+      : TemplateAction(owner, CCSDSCommands::ARBITRARY_RATE) {}
+    
+    Parameter<uint32_t> bitrate = Parameter<uint32_t>::createParameter(this, "Bitrate");
+};
+class EnableTxClkManipulatorAction
+    : public TemplateAction<CCSDSHandler, EnableTxClkManipulatorAction, CCSDSCommands> {
+ public:
+  EnableTxClkManipulatorAction(CCSDSHandler* owner)
+      : TemplateAction(owner, CCSDSCommands::ENABLE_TX_CLK_MANIPULATOR) {}
+};
+class DisableTxClkManipulatorAction
+    : public TemplateAction<CCSDSHandler, DisableTxClkManipulatorAction, CCSDSCommands> {
+ public:
+  DisableTxClkManipulatorAction(CCSDSHandler* owner)
+      : TemplateAction(owner, CCSDSCommands::DISABLE_TX_CLK_MANIPULATOR) {}
+};
+class UpdateOnRisingEdgeAction
+    : public TemplateAction<CCSDSHandler, UpdateOnRisingEdgeAction, CCSDSCommands> {
+ public:
+  UpdateOnRisingEdgeAction(CCSDSHandler* owner)
+      : TemplateAction(owner, CCSDSCommands::UPDATE_ON_RISING_EDGE) {}
+};
+class UpdateOnFallingEdgeAction
+    : public TemplateAction<CCSDSHandler, UpdateOnFallingEdgeAction, CCSDSCommands> {
+ public:
+  UpdateOnFallingEdgeAction(CCSDSHandler* owner)
+      : TemplateAction(owner, CCSDSCommands::UPDATE_ON_FALLING_EDGE) {}
+};

mission/tmtc/CCSDSHandler.cpp

@@ -159,6 +159,8 @@ void CCSDSHandler::readCommandQueue(void) {
 
 MessageQueueId_t CCSDSHandler::getCommandQueue() const { return commandQueue->getId(); }
 
+ActionHelper* CCSDSHandler::getActionHelper() { return &actionHelper; }
+
 void CCSDSHandler::addVirtualChannel(VcId_t vcId, VirtualChannel* virtualChannel) {
   if (vcId > common::NUMBER_OF_VIRTUAL_CHANNELS) {
     sif::warning << "CCSDSHandler::addVirtualChannel: Invalid virtual channel ID" << std::endl;
@@ -210,57 +212,74 @@ MessageQueueId_t CCSDSHandler::getRequestQueue() {
   return tcDistributorQueueId;
 }
 
-ReturnValue_t CCSDSHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                          const uint8_t* data, size_t size) {
-  ReturnValue_t result = RETURN_OK;
-  switch (actionId) {
-    case SET_LOW_RATE: {
-      result = ptmeConfig->setRate(RATE_100KBPS);
-      break;
-    }
-    case SET_HIGH_RATE: {
-      result = ptmeConfig->setRate(RATE_500KBPS);
-      break;
-    }
-    case ARBITRARY_RATE: {
-      uint32_t bitrate = 0;
-      SerializeAdapter::deSerialize(&bitrate, &data, &size, SerializeIF::Endianness::BIG);
-      result = ptmeConfig->setRate(bitrate);
-      break;
-    }
-    case EN_TRANSMITTER: {
-      enableTransmit();
-      return EXECUTION_FINISHED;
-    }
-    case DISABLE_TRANSMITTER: {
-      disableTransmit();
-      return EXECUTION_FINISHED;
-    }
-    case ENABLE_TX_CLK_MANIPULATOR: {
-      result = ptmeConfig->configTxManipulator(true);
-      break;
-    }
-    case DISABLE_TX_CLK_MANIPULATOR: {
-      result = ptmeConfig->configTxManipulator(false);
-      break;
-    }
-    case UPDATE_ON_RISING_EDGE: {
-      result = ptmeConfig->invertTxClock(false);
-      break;
-    }
-    case UPDATE_ON_FALLING_EDGE: {
-      result = ptmeConfig->invertTxClock(true);
-      break;
-    }
-    default:
-      return COMMAND_NOT_IMPLEMENTED;
+ReturnValue_t CCSDSHandler::executeAction(Action* action) { return action->handle(); }
+
+ReturnValue_t CCSDSHandler::handleAction(SetLowRateAction* action) {
+  ReturnValue_t result = ptmeConfig->setRate(RATE_100KBPS);
+  if (result == HasReturnvaluesIF::RETURN_OK) {
+    return EXECUTION_FINISHED;
   }
-  if (result != RETURN_OK) {
-    return result;
+  return result;
+}
+
+ReturnValue_t CCSDSHandler::handleAction(SetHighRateAction* action) {
+  ReturnValue_t result = ptmeConfig->setRate(RATE_500KBPS);
+  if (result == HasReturnvaluesIF::RETURN_OK) {
+    return EXECUTION_FINISHED;
   }
+  return result;
+}
+
+ReturnValue_t CCSDSHandler::handleAction(ArbitraryRateAction* action) {
+  ReturnValue_t result = ptmeConfig->setRate(action->bitrate);
+  if (result == HasReturnvaluesIF::RETURN_OK) {
+    return EXECUTION_FINISHED;
+  }
+  return result;
+}
+
+ReturnValue_t CCSDSHandler::handleAction(EnTransmitterAction* action) {
+  enableTransmit();
   return EXECUTION_FINISHED;
 }
 
+ReturnValue_t CCSDSHandler::handleAction(DisableTransmitterAction* action) {
+  disableTransmit();
+  return EXECUTION_FINISHED;
+}
+
+ReturnValue_t CCSDSHandler::handleAction(EnableTxClkManipulatorAction* action) {
+  ReturnValue_t result = ptmeConfig->configTxManipulator(true);
+  if (result == HasReturnvaluesIF::RETURN_OK) {
+    return EXECUTION_FINISHED;
+  }
+  return result;
+}
+
+ReturnValue_t CCSDSHandler::handleAction(DisableTxClkManipulatorAction* action) {
+  ReturnValue_t result = ptmeConfig->configTxManipulator(false);
+  if (result == HasReturnvaluesIF::RETURN_OK) {
+    return EXECUTION_FINISHED;
+  }
+  return result;
+}
+
+ReturnValue_t CCSDSHandler::handleAction(UpdateOnRisingEdgeAction* action) {
+  ReturnValue_t result = ptmeConfig->invertTxClock(false);
+  if (result == HasReturnvaluesIF::RETURN_OK) {
+    return EXECUTION_FINISHED;
+  }
+  return result;
+}
+
+ReturnValue_t CCSDSHandler::handleAction(UpdateOnFallingEdgeAction* action) {
+  ReturnValue_t result = ptmeConfig->invertTxClock(true);
+  if (result == HasReturnvaluesIF::RETURN_OK) {
+    return EXECUTION_FINISHED;
+  }
+  return result;
+}
+
 void CCSDSHandler::checkEvents() {
   EventMessage event;
   for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == RETURN_OK;

mission/tmtc/CCSDSHandler.h

@@ -3,6 +3,7 @@
 
 #include <unordered_map>
 
+#include "CCSDSActions.h"
 #include "OBSWConfig.h"
 #include "VirtualChannel.h"
 #include "fsfw/action/ActionHelper.h"
@@ -76,8 +77,17 @@ class CCSDSHandler : public SystemObject,
   uint16_t getIdentifier() override;
   MessageQueueId_t getRequestQueue() override;
 
-  virtual ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
-                                      const uint8_t* data, size_t size);
+  virtual ActionHelper* getActionHelper() override;
+  virtual ReturnValue_t executeAction(Action* action);
+  ReturnValue_t handleAction(SetLowRateAction* action);
+  ReturnValue_t handleAction(SetHighRateAction* action);
+  ReturnValue_t handleAction(EnTransmitterAction* action);
+  ReturnValue_t handleAction(DisableTransmitterAction* action);
+  ReturnValue_t handleAction(ArbitraryRateAction* action);
+  ReturnValue_t handleAction(EnableTxClkManipulatorAction* action);
+  ReturnValue_t handleAction(DisableTxClkManipulatorAction* action);
+  ReturnValue_t handleAction(UpdateOnRisingEdgeAction* action);
+  ReturnValue_t handleAction(UpdateOnFallingEdgeAction* action);
 
  private:
   static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER;
@@ -85,18 +95,6 @@ class CCSDSHandler : public SystemObject,
 
   static const uint32_t QUEUE_SIZE = common::CCSDS_HANDLER_QUEUE_SIZE;
 
-  static const ActionId_t SET_LOW_RATE = 0;
-  static const ActionId_t SET_HIGH_RATE = 1;
-  static const ActionId_t EN_TRANSMITTER = 2;
-  static const ActionId_t DISABLE_TRANSMITTER = 3;
-  static const ActionId_t ARBITRARY_RATE = 4;
-  static const ActionId_t ENABLE_TX_CLK_MANIPULATOR = 5;
-  static const ActionId_t DISABLE_TX_CLK_MANIPULATOR = 6;
-  // Will update data with respect to tx clock signal of cadu bitstream on rising edge
-  static const ActionId_t UPDATE_ON_RISING_EDGE = 7;
-  // Will update data with respect to tx clock signal of cadu bitstream on falling edge
-  static const ActionId_t UPDATE_ON_FALLING_EDGE = 8;
-
   // Syrlinks supports two bitrates (200 kbps and 1000 kbps)
   // Due to convolutional code added by the syrlinks the input frequency must be half the
   // target frequency
@@ -145,6 +143,17 @@ class CCSDSHandler : public SystemObject,
 
   bool linkState = DOWN;
 
+  // instances of the actions
+  SetLowRateAction setLowRateAction = SetLowRateAction(this);
+  SetHighRateAction setHighRateAction = SetHighRateAction(this);
+  EnTransmitterAction enTransmitterAction = EnTransmitterAction(this);
+  DisableTransmitterAction disableTransmitterAction = DisableTransmitterAction(this);
+  ArbitraryRateAction arbitraryRateAction = ArbitraryRateAction(this);
+  EnableTxClkManipulatorAction enableTxClkManipulatorAction = EnableTxClkManipulatorAction(this);
+  DisableTxClkManipulatorAction disableTxClkManipulatorAction = DisableTxClkManipulatorAction(this);
+  UpdateOnRisingEdgeAction updateOnRisingEdgeAction = UpdateOnRisingEdgeAction(this);
+  UpdateOnFallingEdgeAction updateOnFallingEdgeAction = UpdateOnFallingEdgeAction(this);
+
   void readCommandQueue(void);
   void handleTelemetry();
   void handleTelecommands();

mission/tmtc/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_EIVE_MISSION} PRIVATE
-	CCSDSHandler.cpp
- 	VirtualChannel.cpp
- 	TmFunnel.cpp
-)
+target_sources(${LIB_EIVE_MISSION} PRIVATE CCSDSHandler.cpp VirtualChannel.cpp
+                                           TmFunnel.cpp)

mission/utility/CMakeLists.txt

@@ -1,5 +1,2 @@
-target_sources(${LIB_EIVE_MISSION} PRIVATE
-	Timestamp.cpp
-	ProgressPrinter.cpp
-	Filenaming.cpp
-)
+target_sources(${LIB_EIVE_MISSION} PRIVATE Timestamp.cpp ProgressPrinter.cpp
+                                           Filenaming.cpp)

scripts/install-obsw-yocto.sh

@@ -2,9 +2,11 @@
 # This is a helper script to install the compiles EIVE OBSW files
 # into the yocto repository to re-generate the mission root filesystem
 build_dir=cmake-build-release-q7s
+em_install="0"
 if [ ! -z ${1} ]; then
   if [[ "${1}" == "em" ]]; then
     echo "-I- Installing EM binaries"
+    em_install="1"
     build_dir=cmake-build-release-q7s-em
   fi
 fi
@@ -17,6 +19,13 @@ q7s_package_path="q7s-package/${q7s_yocto_dir}"
 
 obsw_version_filename="obsw_version.txt"
 yocto_obsw_path="yocto/meta-eive/recipes-core/eive-obsw/files"
+variant_specific_path=""
+if [ ${em_install} == "1" ]; then
+  variant_specific_path="${yocto_obsw_path}/em"
+else
+  variant_specific_path="${yocto_obsw_path}/fm"
+fi
+
 yocto_watchdog_path="yocto/meta-eive/recipes-support/eive-obsw-watchdog/files"
 obsw_bin_name="eive-obsw"
 watchdog_bin_name="eive-watchdog"
@@ -27,7 +36,7 @@ if [ ! -z ${EIVE_OBSW_ROOT} ]; then
 	cd ${EIVE_OBSW_ROOT}
   obsw_root=$(pwd)
 elif [ -d ${build_dir} ]; then
-  obsw_root=${build_dir}
+  obsw_root=$(pwd)
   :
 elif [ -d ../${build_dir} ]; then
   cd ..
@@ -66,10 +75,10 @@ fi
 if [ ! -f ${build_dir}/${obsw_bin_name} ]; then
   echo "-W- No EIVE OBSW binary found to intall to yocto"
 else
-  cp_cmd="cp $(pwd)/${build_dir}/${obsw_bin_name} ${yocto_root}/${yocto_obsw_path}/${obsw_target_name}"
+  cp_cmd="cp $(pwd)/${build_dir}/${obsw_bin_name} ${yocto_root}/${variant_specific_path}/${obsw_target_name}"
   echo "-I- Executing: ${cp_cmd}"
   eval ${cp_cmd}
-  cp_ver_cmd="cp $(pwd)/${obsw_version_filename} ${yocto_root}/${yocto_obsw_path}"
+  cp_ver_cmd="cp $(pwd)/${obsw_version_filename} ${yocto_root}/${variant_specific_path}"
   echo "-I- Executing: ${cp_ver_cmd}"
   eval ${cp_ver_cmd}
   echo "-I- Installed EIVE OBSW into yocto repository successfully"

scripts/q7s-env-em.sh

@@ -4,7 +4,7 @@
 # custom cross-compiler and sysroot path setups
 
 # Adapt the following two entries to your need
-CROSS_COMPILE_BIN_PATH="$HOME/EIVE/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin"
+CROSS_COMPILE_BIN_PATH="/opt/q7s-gcc/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin"
 export ZYNQ_7020_SYSROOT="/opt/xiphos/sdk/ark/sysroots/cortexa9hf-neon-xiphos-linux-gnueabi"
 
 export PATH=$PATH:${CROSS_COMPILE_BIN_PATH}

scripts/q7s-env.sh

@@ -4,7 +4,7 @@
 # custom cross-compiler and sysroot path setups
 
 # Adapt the following two entries to your need
-CROSS_COMPILE_BIN_PATH="$HOME/EIVE/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin"
+CROSS_COMPILE_BIN_PATH="/opt/q7s-gcc/gcc-arm-8.3-2019.03-x86_64-arm-linux-gnueabihf/bin"
 export ZYNQ_7020_SYSROOT="/opt/xiphos/sdk/ark/sysroots/cortexa9hf-neon-xiphos-linux-gnueabi"
 
 export PATH=$PATH:${CROSS_COMPILE_BIN_PATH}