210 changed files with 5264 additions and 13525 deletions
--- a/.gitignore
+++ b/.gitignore
@ -22,7 +22,3 @@ __pycache__
 !/.idea/cmake.xml
 generators/*.db
 # Clangd LSP
 /compile_commands.json
 /.cache
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -16,475 +16,6 @@ will consitute of a breaking change warranting a new major release:
 # [unreleased]
 # [v8.2.0] 2024-06-26
 ## Changed
 - STR quaternions are now used by the `MEKF` by default
 - Changed nominal `SUS Assembly` side to `B Side`.
 - Changed source for state machine of detumbling to SUS and MGM only.
 - Changed `FusedRotRateData` dataset to always display rotation rate from SUS and MGM.
 - Solution from `QUEST` will be set to invalid if sun vector and magnetic field vector are too close
  to each other.
 - Changed collection intervals of dataset collection
  - `GPS Controller`: `GPS Set` to 60s
  - `MTQ Handler`: `HK with Torque`, `HK without Torque` to 60s
  - `RW Handler`: `Status Set` to 30s
  - `STR Handler`: `Solution Set` to 30s
  - `ACS Controller`: `MGM Sensor`, `MGM Processed`, `SUS Sensor`, `SUS Processed`, `GYR Sensor`,
    `GPS Processed` to 60s
  - `ACS Controller` at or below `IDLE`: `CTRL Values`, `ACT Commands`, `Attitude Estimation`,
    `Fused Rotation Rate` to 30s
  - `ACS Controller` above `IDLE`: `CTRL Values`, `ACT Commands`, `Attitude Estimation`,
    `Fused Rotation Rate` to 10s
 ## Fixed
 - Added null termination for PLOC MPSoC image taking command which could possibly lead to
  default target filenames.
 # [v8.1.1] 2024-06-05
 ## Added
 - PLOC SUPV MPSoC update re-try logic for the `WRITE_MEMORY` command. These packets form  > 98%
  of all packets required for a software update, but the update mechanism is not tolerant against
  occasional glitches on the RS485 communication to the PLOC SUPV. A simple re-try mechanism which
  tries to re-attempt packet handling up to three times for those packets is introduced.
 # [v8.1.0] 2024-05-29
 ## Fixed
 - Small fix for transition failure handling of the MPSoC when the `START_MPSOC` action command
  to the supervisor fails.
 - Fixed inits of arrays within the `MEKF` not being zeros.
 - Important bugfix for PLOC SUPV: The SUPV previously was able to steal packets from the special
  communication helper, for example during software updates.
 - Corrected sigma of STR for `MEKF`.
 ## Added
 - Added new command to cancel the PLOC SUPV special communication helper.
 # [v8.0.0] 2024-05-13
 - `eive-tmtc` v7.0.0
 ## Fixed
 - Fixed calculation for target rotation rate during pointing modes.
 - Possible fix for MPSoC file read algorithm.
 ## Changed
 - Reworked MPSoC handler to be compatible to new MPSoC software image and use
  new device handler base class. This should increase the reliability of the communication
  significantly.
 - MPSoC device modes IDLE, SNAPSHOT and REPLAY are now modelled using submodes.
 - Commanding a submode the device is already in will not result in a completion failure
  anymore.
 ## Added
 - Added `VERIFY_BOOT` command for MPSoC.
 - New command for MPSoC to store camera image in chunks.
 # [v7.8.1] 2024-04-11
 ## Fixed
 - Reverted fix for wrong order in quaternion multiplication for computation of the error quaternion.
 # [v7.8.0] 2024-04-10
 ## Changed
 - Reverted lower OP limit of `PLOC` to -10°C.
 - All pointing laws are now allowed to use the `MEKF` per default.
 - Changed limits in `PWR Controller`.
 - PUS time service: Now dumps the time before and after relative timeshift or setting absolute time
 - The `GPS Controller` does not set itself to `OFF` anymore, if it has not detected a valid fix for
  some time. Instead it attempts to reset both GNSS devices once.
 - The maximum time to reach a fix is shortened from 30min to 15min.
 - The time the reset pin of the GNSS devices is pulled is prolonged from 5ms to 10s.
 - A `GPS FIX HAS CHANGED` is now only triggered if no fix change has been detected within the past
  2min. This means, this event might be thrown with a 2min delay. It is instantly thrown, if the mode
  of the controller is changed. As arguments it now displays the new fix and the numer of fix changes
  missed.
 - The number of satellites seen and used is reset to 0, in case they are set to invalid.
 - Altitude, latitude and longitude messages are not checked anymore, in case the mode message was
  already invalid.
 ## Added
 - PUS timeservice relative timeshift.
 ## Fixed
 - Fixed wrong order in quaternion multiplication for computation of the error quaternion.
 - Re-worked some FDIR logic in the FSFW. The former logic prevented events with a severity
  higher than INFO if the device was in EXTERNAL CONTROL. The new logic will allow to trigger
  events but still inhibit FDIR reactions if the device is in EXTERNAL CONTROL.
 # [v7.7.4] 2024-03-21
 ## Changed
 - Rotational rate limit for the GS target pointing is now seperated from controller limit. It
  is also reduced to 0.75°/s now.
 ## Fixed
 - Fixed wrong sign in calculation of total current within the `PWR Controller`.
 # [v7.7.3] 2024-03-18
 - Bumped `eive-fsfw`
 ## Added
 - Added parameter to disable STR input for MEKF.
 ## Changed
 - If a primary heater is set to `EXTERNAL CONTROL` and `ON`, the `TCS Controller` will no
  try to control the temperature of that object.
 - Set lower OP limit of `PLOC` to -5°C.
 ## Fixed
 - Added prevention of sign jump for target quaternion of GS pointing, which would reduce the
  performance of the controller.
 - Heaters set to `EXTERNAL CONTROL` no longer can be switched off by the `TCS Controller`, if
  they violate the maximum burn duration of the controller.
 # [v7.7.2] 2024-03-06
 ## Fixed
 - Camera and E-band antenna now point towards the target instead of away from the target for the
  pointing target mode.
 # [v7.7.1] 2024-03-06
 - Bumped `eive-tmtc` to v6.1.1
 - Bumped `eive-fsfw`
 ## Added
 - The `CoreController` now sets the leap seconds on initalization. They are stored in a persistent
  file. If the file does yet not exist, it will be created. The leap seconds can be updated using an
  action command. This will also update the file.
 ## Fixed
 - Fixed wrong dimension of a matrix within the `MEKF`, which would lead to a seg fault, if the
  star tracker was available.
 - Fixed case in which control values within the `AcsController` could become NaN.
 # [v7.7.0] 2024-02-29
 - Bumped `eive-tmtc` to v6.1.0
 - Bumped `eive-fsfw`
 ## Fixed
 - PLOC SUPV sets: Added missing `PoolReadGuard` instantiations when reading boot status report
  and latchup status report.
 - PLOC SUPV latchup report could not be handled previously.
 - Bugfix in PLOC SUPV latchup report parsing.
 - Bugfix in PLOC MPSoC HK set: Set and variables were not set valid.
 - The `PTG_CTRL_NO_ATTITUDE_INFORMATION` will now actually trigger a fallback into safe mode
  and is triggered by the `AcsController` now.
 - Fixed a corner case, in which an invalid speed command could be sent to the `RwHandler`.
 - Fixed calculation of desaturation torque for faulty RWs.
 - Fixed bugs within the `MEKF` and simplified the code.
 ## Changed
 - `FusedRotationRate` now only uses rotation rate from QUEST and STR in higher modes
 - QUEST and STR rates are now allowed per default
 - Changed PTG Strat priorities to favor STR before MEKF.
 - Increased message queue depth and maximum number of handled messages per cycle for
  `PusServiceBase` based classes (especially PUS scheduler).
 - `MathOperations` functions were moved to their appropriate classes within the `eive-fsfw`
 - Changed pointing strategy for target groundstation mode to prevent blinding of the STR. This
  also limits the rotation for the reference target quaternion to prevent spikes in required
  rotation rates.
 - Updated QUEST and Sun Vector Params to new values.
 - Removed the satellites's angular momentum from desaturation calculation.
 - Bumped internal `sagittactl` library to v11.11.
 ## Added
 - Updated STR handler to unlock and allow using the secondary firmware slot.
 - STR handling for new BlobStats TM set.
 - Added new action command to update the standard deviations within the `MEKF` from the
  `AcsParameters`.
 # [v7.6.1] 2024-02-05
 ## Changed
 - Guidance now uses the coordinate functions from the FSFW.
 - Idle should now point the STR away from the earth
 ## Fixed
 - Fixed bugs in `Guidance::comparePtg` and corrected overloading
 - Detumbling State Machine is now robust to commanded mode changes.
 # [v7.6.0] 2024-01-30
 - Bumped `eive-tmtc` to v5.13.0
 - Bumped `eive-fsfw`
 ## Added
 - Added new parameter for MPSoC which allows to skip SUPV commanding.
 ## Changed
 - Increased allowed mode transition time for PLOC SUPV.
 - Detumbling can now be triggered from all modes of the `AcsController`. In case the
  current mode is a higher pointing mode, the STR will be set to faulty, to trigger a
  transition to safe first. Then, in a second step, a transition to detumble is triggered.
 ## Fixed
 - If the PCDU handler fails reading data from the IPC store, it will
  not try to do a deserialization anymore.
 - All action commands sent by the PLOC SUPV to itself will have no sender now.
 - RW speed commands get reset to 0 RPM, if the `AcsController` has changed its mode
  to Safe
 - Antistiction for RWs will set commanded speed to 0 RPM, if a wheel is detected as not
  working
 - Removed parameter to disable antistiction, as deactivating it would result in the
  `AcsController` being allowed sending invalid speed commands to the RW Handler, which
  would then trigger FDIR and turning off the functioning device
 - `RwHandler` returnvalues would use the `INTERFACE_ID` of the `DeviceHandlerBase`
 - The `AcsController` will reset its stored guidance values on mode change and lost
  orientation.
 - The nullspace controller will only be used if all RWs are available.
 - Calculation of required rotation rate in pointing modes has been fixed to actual
  calculation of rotation rate from two quaternions.
 - Fixed alignment matrix and pseudo inverses of RWs, to match the wrong definition of
  positive rotation.
 # [v7.5.5] 2024-01-22
 ## Fixed
 - Calculation of error quaternion was done with inverse of the required target quaternion.
 # [v7.5.4] 2024-01-16
 ## Fixed
 - Pointing strategy now actually uses fused rotation rate source instead of its valid flag.
 - All datasets now get updated during pointing mode, even if the strategy is a fault one.
 # [v7.5.3] 2023-12-19
 ## Fixed
 - Set STR quaternions to invalid in device handler if the solution is not trustworthy.
 # [v7.5.2] 2023-12-14
 ## Fixed
 - Fixed faulty scaling within the QUEST algorithm.
 # [v7.5.1] 2023-12-13
 - `eive-tmtc` v5.12.1
 ## Changed
 - Increased the maximum number of scheduled telecommands from 500 to 4000. Merry Christmas!
 ## Fixed
 - Faulty mapping of input values for QUEST algorithm.
 - Fixed validity check for QUEST algorithm.
 # [v7.5.0] 2023-12-06
 - `eive-tmtc` v5.12.0
 ## Changed
 - ACS-Board default side changed to B-Side
 - The TLE uploaded now gets stored in a file on the filesystem. It will always be stored on
  the current active SD Card. After a reboot, the TLE will be read from the filesystem.
  A filesystem change via `prefSD` on bootup, can lead to the TLE not being read, even
  though it is there.
 - Added action cmd to read the currently stored TLE.
 - Both the `AcsController` and the `PwrController` now use the monotonic clock to calculate
  the time difference.
 - `ACS Controller` now has the function `performAttitudeControl` which is called prior to passing
  on to the relevant mode functions. It handles all telemetry relevant functions, which were
  always called, regardless of the mode.
 ## Added
 - Higher ACS modes can now be entered without a running `MEKF`. Higher modes will collect their
  quaternion and rotational rate depending on the available sources.
 - `QUEST` attitude estimation was added to the `AcsController`.
 - The fused rotational rate can now be estimated from `QUEST` and the `STR`.
 # [v7.4.1] 2023-12-06
 ## Fixed
 - Schedule SCEX again. Scheduling was removed accidentaly when Payload Task was converted to a PST.
 - SCEX transition was previously 0 seconds.. which did not lead to bugs? In any case it is 5
  seconds now.
 # [v7.4.0] 2023-11-30
 - `eive-tmtc` v5.11.0
 ## Changed
 - Rewrote the PLOC Supervisor Handler, which is now based on a new device handler base class.
  Added ADC and Logging Counters telemetry set support.
 ## Fixed
 - Increase allowed time for PTME writers to finish partial transfers. A duration of 200 ms was
  not sufficient for cases where 3 writers write concurrently.
 - Fixed state issue for PTME writer object where the writer was not reset properly after a timeout
  of a partial transfer. This was a major bug blocking the whole VC if it occured.
 - STR config path was previously hardcoded to `/mnt/sd0/startracker/flight-config.json`.
  A new abstraction was introduces which now uses the active SD card to build the correct
  config path when initializing the star tracker.
 ## Added
 - PL PCDU: Add command to enable and disable channel order checks.
 - Added new PUS 15 subservice `DELETE_BY_TIME_RANGE` which allows to also specify a deletion
  start time when deleting packets from the persistent TM store.
 - Introduced a new `RELOAD_JSON_CFG_FILE` command for the STR to reload the JSON configuration
  data based on the current output of the config file path getter function. A reboot of the
  device is still necessary to load the configuration to the STR.
 # [v7.3.0] 2023-11-07
 ## Changed
 - Changed PDEC addresses depending on which firmware version is used. It is suspected that
  the previous addresses were invalid and not properly covered by the Linux memory protection.
  The OBSW will use the old addresses for older FW versions.
 - Reverted some STR ComIF behaviour back to an older software version.
 ## Added
 - Always add PLOC MPSoC and PLOC SUPV components for the EM as well.
 # [v7.2.0] 2023-10-27
 - `eive-tmtc` v5.10.1
 ## Added
 - STR: Added new TM sets: Blob, Blobs, MatchedCentroids, Contrast, AutoBlob, Centroid, Centroids
 - STR: Added new mechanism where the secondary TM which is polled can now be a set instead of
  being temperature only. An API is exposed which allows to add a data set to that set of secondary
  telemetry, reset it back to temperature only, and read the whole set. This allows more debugging
  capability.
 - CFDP source handler, which allows file downlink using the standardized
  CFDP interface.
 - Proper back pressure handling for the CFDP handler, where the `LiveTmTask` is able to throttle
  the CFDP handler.
 - Added CFDP fault handler events.
 - The EIVE system will command the payload OFF explicitely again when receiving the
  `power::POWER_LEVEL_CRITICAL` event.
 ## Fixed
 - If the PTME is driven in a way where it fills faster than it can be emptied, the interface
  can become full during the process of a regular packet write. The interface of the PAPB VC
  was adapted to be stateful now. Packet generation is started with a `write` call while
  write transfers are advanced and completed with the `advanceWrite` call if they can not be
  completed immediately.
 - CFDP Space Packets SSC is now generated properly, was always 0 before.
 - Host build fixes
 - PL Enable set of the power controller is now set to invalid properly if the power controller
  is not in normal mode.
 - MPSoC debug mode.
 - Possible bugfix for PL PCDU parameter JSON handling which might not have been initialized
  properly from the JSON file.
 ## Changed
 - Swapped RTD 9 (PLOC HPA Sensor) and RTD 11 (PLOC MPA Sensor) chip select definitions. It is
  strongly suspected the cables for those devices were swapped during integration. This is probably
  the easiest way to fix the issue without the need to tweak ground or other OBSW or controller
  code.
 - Added a 3 second delay in the EIVE system between commanding all PL components except the SUPV,
  and the SUPV itself OFF when the power level becomes low or critical.
 - SUS FDIR should now trigger less events. The finish event is now only triggered once the
  SUS has been working properly for a minute again. It will then display the number of periods
  during which the SUS was not working as well as the maximum amount of invalid messages.
 - Updated battery internal resistance to new value
 # [v7.1.0] 2023-10-11
 - Bumped `eive-tmtc` to v5.8.0.
 - Activate Xiphos WDT with a timeout period of 80 seconds using the `libxiphos` API. The WDT
  calls are done by the new `XiphosWdtHandler` object.
 # [v7.0.0] 2023-10-11
 - Bumped `eive-tmtc` to v5.7.1.
 - Bumped `eive-fsfw`
 ## Added
 - EPS Subsystem has been added to EIVE System Tree
 - Power Controller for calculating the State of Charge and FDIR regarding low SoC has been
  introduced.
 ## Changed
 - Changed internals for MPSoC boot process to make the code more understandable and some
  parameters better configurable. This should not affect the behaviour of the OBSW, but might
  make it more reliable and fix some corner cases.
 ## Fixed
 - Missing `nullptr` checks for PLOC Supervisor handler, which could lead to crashes.
 - SCEX bugfix for normal and transition commanding.
 # [v6.6.0] 2023-09-18
 ## Changed
 - Changed the memory initialized for the PDEC Config Memory and the PDEC RAM by using `mmap`
  directly and ignoring UIO. This makes the OBSW compatible to a device tree update, where those
  memory segments are marked reserved and are thus not properly accessible through the UIO API
  anymore. This change should be downwards compatible to older device trees.
 # [v6.5.1] 2023-09-12
 - Bumped `eive-tmtc` to v5.5.0.
 # [v6.5.0] 2023-09-12
 ## Changed
 - Relaxed SUS FDIR. The devices have shown to be glitchy in orbit, but still seem to deliver
  sensible raw values most of the time. Some further testing is necessary, but some changes in the
  code should cause the SUS devices to remain healthy for now.
 - The primary and the secondary temperature sensors for the PLOC mission boards are exchanged.
 - ACS parameters for the SUSMGM (FLP) safe mode have been adjusted. This safe mode is now the
  default one.
 - MGM3100 Startup Configuration: Ignore bit 1 of the CMM reply, which is sometimes set to
  1 in the reply for some reason.
 # [v6.4.1] 2023-08-21
 ## Fixed
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -9,9 +9,9 @@
 # ##############################################################################
 cmake_minimum_required(VERSION 3.13)
-set(OBSW_VERSION_MAJOR 8)
+set(OBSW_VERSION_MAJOR 6)
-set(OBSW_VERSION_MINOR 2)
+set(OBSW_VERSION_MINOR 4)
-set(OBSW_VERSION_REVISION 0)
+set(OBSW_VERSION_REVISION 1)
 # set(CMAKE_VERBOSE TRUE)
@ -64,7 +64,7 @@ include(EiveHelpers)
 option(EIVE_ADD_ETL_LIB "Add ETL library" ON)
 option(EIVE_ADD_JSON_LIB "Add JSON library" ON)
-set(OBSW_MAX_SCHEDULED_TCS 4000)
+set(OBSW_MAX_SCHEDULED_TCS 500)
 if(EIVE_Q7S_EM)
  set(OBSW_Q7S_EM
@ -126,13 +126,13 @@ set(OBSW_ADD_HEATERS
    1
    CACHE STRING "Add TCS heaters")
 set(OBSW_ADD_PLOC_SUPERVISOR
-    1
+    ${INIT_VAL}
    CACHE STRING "Add PLOC supervisor handler")
 set(OBSW_ADD_SA_DEPL
    ${INIT_VAL}
    CACHE STRING "Add SA deployment handler")
 set(OBSW_ADD_PLOC_MPSOC
-    1
+    ${INIT_VAL}
    CACHE STRING "Add MPSoC handler")
 set(OBSW_ADD_ACS_CTRL
    ${INIT_VAL}
--- a/archive/PlocMpsocSpecialComHelperLegacy.cpp
+++ b/archive/PlocMpsocSpecialComHelperLegacy.cpp
@ -1,545 +0,0 @@
 #include <fsfw/globalfunctions/arrayprinter.h>
 #include <fsfw/tasks/TaskFactory.h>
 #include <linux/payload/PlocMpsocSpecialComHelperLegacy.h>
 #include <unistd.h>
 #include <filesystem>
 #include <fstream>
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/FilesystemHelper.h"
 #endif
 #include "mission/utility/Timestamp.h"
 using namespace ploc;
 PlocMpsocSpecialComHelperLegacy::PlocMpsocSpecialComHelperLegacy(object_id_t objectId)
    : SystemObject(objectId) {
  spParams.buf = commandBuffer;
  spParams.maxSize = sizeof(commandBuffer);
 }
 PlocMpsocSpecialComHelperLegacy::~PlocMpsocSpecialComHelperLegacy() {}
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::initialize() {
 #ifdef XIPHOS_Q7S
  sdcMan = SdCardManager::instance();
  if (sdcMan == nullptr) {
    sif::warning << "PlocMPSoCHelper::initialize: Invalid SD Card Manager" << std::endl;
    return returnvalue::FAILED;
  }
 #endif
  return returnvalue::OK;
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::performOperation(uint8_t operationCode) {
  ReturnValue_t result = returnvalue::OK;
  semaphore.acquire();
  while (true) {
 #if OBSW_THREAD_TRACING == 1
    trace::threadTrace(opCounter, "PLOC MPSOC Helper");
 #endif
    switch (internalState) {
      case InternalState::IDLE: {
        semaphore.acquire();
        break;
      }
      case InternalState::FLASH_WRITE: {
        result = performFlashWrite();
        if (result == returnvalue::OK) {
          triggerEvent(MPSOC_FLASH_WRITE_SUCCESSFUL, sequenceCount->get());
        } else {
          triggerEvent(MPSOC_FLASH_WRITE_FAILED, sequenceCount->get());
        }
        internalState = InternalState::IDLE;
        break;
      }
      case InternalState::FLASH_READ: {
        result = performFlashRead();
        if (result == returnvalue::OK) {
          triggerEvent(MPSOC_FLASH_READ_SUCCESSFUL, sequenceCount->get());
        } else {
          triggerEvent(MPSOC_FLASH_READ_FAILED, sequenceCount->get());
        }
        internalState = InternalState::IDLE;
        break;
      }
      default:
        sif::debug << "PlocMPSoCHelper::performOperation: Invalid state" << std::endl;
        break;
    }
  }
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::setComIF(
    DeviceCommunicationIF* communicationInterface_) {
  uartComIF = dynamic_cast<SerialComIF*>(communicationInterface_);
  if (uartComIF == nullptr) {
    sif::warning << "PlocMPSoCHelper::initialize: Invalid uart com if" << std::endl;
    return returnvalue::FAILED;
  }
  return returnvalue::OK;
 }
 void PlocMpsocSpecialComHelperLegacy::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; }
 void PlocMpsocSpecialComHelperLegacy::setSequenceCount(SourceSequenceCounter* sequenceCount_) {
  sequenceCount = sequenceCount_;
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::startFlashWrite(std::string obcFile,
                                                               std::string mpsocFile) {
  if (internalState != InternalState::IDLE) {
    return returnvalue::FAILED;
  }
  ReturnValue_t result = startFlashReadOrWriteBase(std::move(obcFile), std::move(mpsocFile));
  if (result != returnvalue::OK) {
    return result;
  }
  internalState = InternalState::FLASH_WRITE;
  return semaphore.release();
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::startFlashRead(std::string obcFile,
                                                              std::string mpsocFile,
                                                              size_t readFileSize) {
  if (internalState != InternalState::IDLE) {
    return returnvalue::FAILED;
  }
  ReturnValue_t result = startFlashReadOrWriteBase(std::move(obcFile), std::move(mpsocFile));
  if (result != returnvalue::OK) {
    return result;
  }
  flashReadAndWrite.totalReadSize = readFileSize;
  internalState = InternalState::FLASH_READ;
  return semaphore.release();
 }
 void PlocMpsocSpecialComHelperLegacy::resetHelper() {
  spParams.buf = commandBuffer;
  terminate = false;
  uartComIF->flushUartRxBuffer(comCookie);
 }
 void PlocMpsocSpecialComHelperLegacy::stopProcess() { terminate = true; }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::performFlashWrite() {
  ReturnValue_t result = returnvalue::OK;
  std::ifstream file(flashReadAndWrite.obcFile, std::ifstream::binary);
  if (file.bad()) {
    return returnvalue::FAILED;
  }
  result = flashfopen(mpsoc::FileAccessModes::WRITE | mpsoc::FileAccessModes::OPEN_ALWAYS);
  if (result != returnvalue::OK) {
    return result;
  }
  // Set position of next character to end of file input stream
  file.seekg(0, file.end);
  // tellg returns position of character in input stream
  size_t remainingSize = file.tellg();
  size_t dataLength = 0;
  size_t bytesRead = 0;
  while (remainingSize > 0) {
    if (terminate) {
      return returnvalue::OK;
    }
    // The minus 4 is necessary for unknown reasons. Maybe some bug in the ILH software?
    if (remainingSize > mpsoc::MAX_FLASH_WRITE_DATA_SIZE - 4) {
      dataLength = mpsoc::MAX_FLASH_WRITE_DATA_SIZE - 4;
    } else {
      dataLength = remainingSize;
    }
    if (file.bad() or not file.is_open()) {
      return FILE_WRITE_ERROR;
    }
    file.seekg(bytesRead, file.beg);
    file.read(reinterpret_cast<char*>(fileBuf.data()), dataLength);
    bytesRead += dataLength;
    remainingSize -= dataLength;
    mpsoc::TcFlashWrite tc(spParams, *sequenceCount);
    result = tc.setPayload(fileBuf.data(), dataLength);
    if (result != returnvalue::OK) {
      return result;
    }
    result = tc.finishPacket();
    if (result != returnvalue::OK) {
      return result;
    }
    (*sequenceCount)++;
    result = handlePacketTransmissionNoReply(tc);
    if (result != returnvalue::OK) {
      return result;
    }
  }
  result = flashfclose();
  if (result != returnvalue::OK) {
    return result;
  }
  return result;
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::performFlashRead() {
  std::error_code e;
  std::ofstream ofile(flashReadAndWrite.obcFile, std::ios::trunc | std::ios::binary);
  if (ofile.bad()) {
    return returnvalue::FAILED;
  }
  ReturnValue_t result = flashfopen(mpsoc::FileAccessModes::READ);
  if (result != returnvalue::OK) {
    std::filesystem::remove(flashReadAndWrite.obcFile, e);
    return result;
  }
  size_t readSoFar = 0;
  size_t nextReadSize = mpsoc::MAX_FLASH_READ_DATA_SIZE;
  while (readSoFar < flashReadAndWrite.totalReadSize) {
    if (terminate) {
      std::filesystem::remove(flashReadAndWrite.obcFile, e);
      return returnvalue::OK;
    }
    nextReadSize = mpsoc::MAX_FLASH_READ_DATA_SIZE;
    if (flashReadAndWrite.totalReadSize - readSoFar < mpsoc::MAX_FLASH_READ_DATA_SIZE) {
      nextReadSize = flashReadAndWrite.totalReadSize - readSoFar;
    }
    if (ofile.bad() or not ofile.is_open()) {
      std::filesystem::remove(flashReadAndWrite.obcFile, e);
      return FILE_READ_ERROR;
    }
    mpsoc::TcFlashRead flashReadRequest(spParams, *sequenceCount);
    result = flashReadRequest.setPayload(nextReadSize);
    if (result != returnvalue::OK) {
      std::filesystem::remove(flashReadAndWrite.obcFile, e);
      return result;
    }
    result = flashReadRequest.finishPacket();
    if (result != returnvalue::OK) {
      std::filesystem::remove(flashReadAndWrite.obcFile, e);
      return result;
    }
    (*sequenceCount)++;
    result = handlePacketTransmissionFlashRead(flashReadRequest, ofile, nextReadSize);
    if (result != returnvalue::OK) {
      std::filesystem::remove(flashReadAndWrite.obcFile, e);
      return result;
    }
    readSoFar += nextReadSize;
  }
  result = flashfclose();
  if (result != returnvalue::OK) {
    return result;
  }
  return result;
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::flashfopen(uint8_t mode) {
  spParams.buf = commandBuffer;
  mpsoc::FlashFopen flashFopen(spParams, *sequenceCount);
  ReturnValue_t result = flashFopen.setPayload(flashReadAndWrite.mpsocFile, mode);
  if (result != returnvalue::OK) {
    return result;
  }
  result = flashFopen.finishPacket();
  if (result != returnvalue::OK) {
    return result;
  }
  (*sequenceCount)++;
  result = handlePacketTransmissionNoReply(flashFopen);
  if (result != returnvalue::OK) {
    return result;
  }
  return returnvalue::OK;
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::flashfclose() {
  spParams.buf = commandBuffer;
  mpsoc::FlashFclose flashFclose(spParams, *sequenceCount);
  ReturnValue_t result = flashFclose.finishPacket();
  if (result != returnvalue::OK) {
    return result;
  }
  (*sequenceCount)++;
  result = handlePacketTransmissionNoReply(flashFclose);
  if (result != returnvalue::OK) {
    return result;
  }
  return result;
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::handlePacketTransmissionFlashRead(
    mpsoc::TcFlashRead& tc, std::ofstream& ofile, size_t expectedReadLen) {
  ReturnValue_t result = sendCommand(tc);
  if (result != returnvalue::OK) {
    return result;
  }
  result = handleAck();
  if (result != returnvalue::OK) {
    return result;
  }
  result = handleTmReception();
  if (result != returnvalue::OK) {
    return result;
  }
  // We have the nominal case where the flash read report appears first, or the case where we
  // get an EXE failure immediately.
  if (spReader.getApid() == mpsoc::apid::TM_FLASH_READ_REPORT) {
    result = handleFlashReadReply(ofile, expectedReadLen);
    if (result != returnvalue::OK) {
      return result;
    }
    return handleExe();
  } else if (spReader.getApid() == mpsoc::apid::EXE_FAILURE) {
    handleExeFailure();
  } else {
    triggerEvent(MPSOC_EXE_INVALID_APID, spReader.getApid(), static_cast<uint32_t>(internalState));
    sif::warning << "PLOC MPSoC: Expected execution report "
                 << "but received space packet with apid " << std::hex << spReader.getApid()
                 << std::endl;
  }
  return returnvalue::FAILED;
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::handlePacketTransmissionNoReply(ploc::SpTcBase& tc) {
  ReturnValue_t result = sendCommand(tc);
  if (result != returnvalue::OK) {
    return result;
  }
  result = handleAck();
  if (result != returnvalue::OK) {
    return result;
  }
  return handleExe();
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::sendCommand(ploc::SpTcBase& tc) {
  ReturnValue_t result = returnvalue::OK;
  result = uartComIF->sendMessage(comCookie, tc.getFullPacket(), tc.getFullPacketLen());
  if (result != returnvalue::OK) {
    sif::warning << "PlocMPSoCHelper::sendCommand: Failed to send command" << std::endl;
    triggerEvent(MPSOC_SENDING_COMMAND_FAILED, result, static_cast<uint32_t>(internalState));
    return result;
  }
  return result;
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::handleAck() {
  ReturnValue_t result = returnvalue::OK;
  result = handleTmReception();
  if (result != returnvalue::OK) {
    return result;
  }
  result = checkReceivedTm();
  if (result != returnvalue::OK) {
    return result;
  }
  uint16_t apid = spReader.getApid();
  if (apid != mpsoc::apid::ACK_SUCCESS) {
    handleAckApidFailure(spReader);
    return returnvalue::FAILED;
  }
  return returnvalue::OK;
 }
 void PlocMpsocSpecialComHelperLegacy::handleAckApidFailure(const ploc::SpTmReader& reader) {
  uint16_t apid = reader.getApid();
  if (apid == mpsoc::apid::ACK_FAILURE) {
    uint16_t status = mpsoc::getStatusFromRawData(reader.getFullData());
    sif::warning << "PLOC MPSoC ACK Failure: " << mpsoc::getStatusString(status) << std::endl;
    triggerEvent(MPSOC_ACK_FAILURE_REPORT, static_cast<uint32_t>(internalState), status);
  } else {
    triggerEvent(MPSOC_ACK_INVALID_APID, apid, static_cast<uint32_t>(internalState));
    sif::warning << "PlocMPSoCHelper::handleAckApidFailure: Expected acknowledgement report "
                 << "but received space packet with apid " << std::hex << apid << std::endl;
  }
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::handleExe() {
  ReturnValue_t result = returnvalue::OK;
  result = handleTmReception();
  if (result != returnvalue::OK) {
    return result;
  }
  result = checkReceivedTm();
  if (result != returnvalue::OK) {
    return result;
  }
  uint16_t apid = spReader.getApid();
  if (apid == mpsoc::apid::EXE_FAILURE) {
    handleExeFailure();
    return returnvalue::FAILED;
  } else if (apid != mpsoc::apid::EXE_SUCCESS) {
    triggerEvent(MPSOC_EXE_INVALID_APID, apid, static_cast<uint32_t>(internalState));
    sif::warning << "PLOC MPSoC: Expected execution report "
                 << "but received space packet with apid " << std::hex << apid << std::endl;
  }
  return returnvalue::OK;
 }
 void PlocMpsocSpecialComHelperLegacy::handleExeFailure() {
  uint16_t status = mpsoc::getStatusFromRawData(spReader.getFullData());
  sif::warning << "PLOC MPSoC EXE Failure: " << mpsoc::getStatusString(status) << std::endl;
  triggerEvent(MPSOC_EXE_FAILURE_REPORT, static_cast<uint32_t>(internalState));
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::handleTmReception() {
  ReturnValue_t result = returnvalue::OK;
  tmCountdown.resetTimer();
  size_t readBytes = 0;
  size_t currentBytes = 0;
  uint32_t usleepDelay = 5;
  size_t fullPacketLen = 0;
  while (true) {
    if (tmCountdown.hasTimedOut()) {
      triggerEvent(MPSOC_READ_TIMEOUT, tmCountdown.getTimeoutMs());
      return returnvalue::FAILED;
    }
    result = receive(tmBuf.data() + readBytes, 6, &currentBytes);
    if (result != returnvalue::OK) {
      return result;
    }
    spReader.setReadOnlyData(tmBuf.data(), tmBuf.size());
    fullPacketLen = spReader.getFullPacketLen();
    readBytes += currentBytes;
    if (readBytes == 6) {
      break;
    }
    usleep(usleepDelay);
    if (usleepDelay < 200000) {
      usleepDelay *= 4;
    }
  }
  while (true) {
    if (tmCountdown.hasTimedOut()) {
      triggerEvent(MPSOC_READ_TIMEOUT, tmCountdown.getTimeoutMs());
      return returnvalue::FAILED;
    }
    result = receive(tmBuf.data() + readBytes, fullPacketLen - readBytes, &currentBytes);
    readBytes += currentBytes;
    if (fullPacketLen == readBytes) {
      break;
    }
    usleep(usleepDelay);
    if (usleepDelay < 200000) {
      usleepDelay *= 4;
    }
  }
  // arrayprinter::print(tmBuf.data(), readBytes);
  return result;
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::handleFlashReadReply(std::ofstream& ofile,
                                                                    size_t expectedReadLen) {
  ReturnValue_t result = checkReceivedTm();
  if (result != returnvalue::OK) {
    return result;
  }
  uint16_t apid = spReader.getApid();
  if (apid != mpsoc::apid::TM_FLASH_READ_REPORT) {
    triggerEvent(MPSOC_FLASH_READ_PACKET_ERROR, FlashReadErrorType::FLASH_READ_APID_ERROR);
    sif::warning << "PLOC MPSoC Flash Read: Unexpected APID" << std::endl;
    return result;
  }
  const uint8_t* packetData = spReader.getPacketData();
  size_t deserDummy = spReader.getPacketDataLen() - mpsoc::CRC_SIZE;
  uint32_t receivedReadLen = 0;
  // I think this is buggy, weird stuff in the short name field.
  //  std::string receivedShortName = std::string(reinterpret_cast<const char*>(packetData), 12);
  //  if (receivedShortName != flashReadAndWrite.mpsocFile.substr(0, 11)) {
  //    sif::warning << "PLOC MPSoC Flash Read: Missmatch between request file name and "
  //                    "received file name"
  //                 << std::endl;
  //    triggerEvent(MPSOC_FLASH_READ_PACKET_ERROR, FlashReadErrorType::FLASH_READ_FILENAME_ERROR);
  //    return returnvalue::FAILED;
  //  }
  packetData += 12;
  result = SerializeAdapter::deSerialize(&receivedReadLen, &packetData, &deserDummy,
                                         SerializeIF::Endianness::NETWORK);
  if (result != returnvalue::OK) {
    return result;
  }
  if (receivedReadLen != expectedReadLen) {
    sif::warning << "PLOC MPSoC Flash Read: Missmatch between request read length and "
                    "received read length"
                 << std::endl;
    triggerEvent(MPSOC_FLASH_READ_PACKET_ERROR, FlashReadErrorType::FLASH_READ_READLEN_ERROR);
    return returnvalue::FAILED;
  }
  ofile.write(reinterpret_cast<const char*>(packetData), receivedReadLen);
  return returnvalue::OK;
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::fileCheck(std::string obcFile) {
 #ifdef XIPHOS_Q7S
  ReturnValue_t result = FilesystemHelper::checkPath(obcFile);
  if (result != returnvalue::OK) {
    return result;
  }
 #elif defined(TE0720_1CFA)
  if (not std::filesystem::exists(obcFile)) {
    sif::warning << "PlocMPSoCHelper::startFlashWrite: File " << obcFile << "does not exist"
                 << std::endl;
    return returnvalue::FAILED;
  }
 #endif
  return returnvalue::OK;
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::startFlashReadOrWriteBase(std::string obcFile,
                                                                         std::string mpsocFile) {
  ReturnValue_t result = fileCheck(obcFile);
  if (result != returnvalue::OK) {
    return result;
  }
  flashReadAndWrite.obcFile = std::move(obcFile);
  flashReadAndWrite.mpsocFile = std::move(mpsocFile);
  resetHelper();
  return returnvalue::OK;
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::checkReceivedTm() {
  ReturnValue_t result = spReader.checkSize();
  if (result != returnvalue::OK) {
    sif::error << "PLOC MPSoC: Size check on received TM failed" << std::endl;
    triggerEvent(MPSOC_TM_SIZE_ERROR);
    return result;
  }
  result = spReader.checkCrc();
  if (result != returnvalue::OK) {
    sif::warning << "PLOC MPSoC: CRC check failed" << std::endl;
    triggerEvent(MPSOC_TM_CRC_MISSMATCH, *sequenceCount);
    return result;
  }
  uint16_t recvSeqCnt = spReader.getSequenceCount();
  if (recvSeqCnt != *sequenceCount) {
    triggerEvent(MPSOC_HELPER_SEQ_CNT_MISMATCH, *sequenceCount, recvSeqCnt);
    *sequenceCount = recvSeqCnt;
  }
  // This sequence count ping pong does not make any sense but it is how the MPSoC expects it.
  (*sequenceCount)++;
  return returnvalue::OK;
 }
 ReturnValue_t PlocMpsocSpecialComHelperLegacy::receive(uint8_t* data, size_t requestBytes,
                                                       size_t* readBytes) {
  ReturnValue_t result = returnvalue::OK;
  uint8_t* buffer = nullptr;
  result = uartComIF->requestReceiveMessage(comCookie, requestBytes);
  if (result != returnvalue::OK) {
    sif::warning << "PlocMPSoCHelper::receive: Failed to request reply" << std::endl;
    triggerEvent(MPSOC_HELPER_REQUESTING_REPLY_FAILED, result,
                 static_cast<uint32_t>(static_cast<uint32_t>(internalState)));
    return returnvalue::FAILED;
  }
  result = uartComIF->readReceivedMessage(comCookie, &buffer, readBytes);
  if (result != returnvalue::OK) {
    sif::warning << "PlocMPSoCHelper::receive: Failed to read received message" << std::endl;
    triggerEvent(MPSOC_HELPER_READING_REPLY_FAILED, result, static_cast<uint32_t>(internalState));
    return returnvalue::FAILED;
  }
  if (*readBytes > 0) {
    std::memcpy(data, buffer, *readBytes);
  }
  return result;
 }
--- a/archive/PlocMpsocSpecialComHelperLegacy.h
+++ b/archive/PlocMpsocSpecialComHelperLegacy.h
@ -1,200 +0,0 @@
 #ifndef BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_
 #define BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_
 #include <linux/payload/plocMpsocHelpers.h>
 #include <mission/utility/trace.h>
 #include <string>
 #include "OBSWConfig.h"
 #include "fsfw/devicehandlers/CookieIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/osal/linux/BinarySemaphore.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tmtcservices/SourceSequenceCounter.h"
 #include "fsfw_hal/linux/serial/SerialComIF.h"
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/SdCardManager.h"
 #endif
 /**
 * @brief   Helper class for MPSoC of PLOC intended to accelerate large data transfers between
 *          MPSoC and OBC.
 * @author  J. Meier
 */
 class PlocMpsocSpecialComHelperLegacy : public SystemObject, public ExecutableObjectIF {
 public:
  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HELPER;
  //! [EXPORT] : [COMMENT] Flash write fails
  static const Event MPSOC_FLASH_WRITE_FAILED = MAKE_EVENT(0, severity::LOW);
  //! [EXPORT] : [COMMENT] Flash write successful
  static const Event MPSOC_FLASH_WRITE_SUCCESSFUL = MAKE_EVENT(1, severity::INFO);
  //! [EXPORT] : [COMMENT] Communication interface returned failure when trying to send the command
  //! to the MPSoC
  //! P1: Return value returned by the communication interface sendMessage function
  //! P2: Internal state of MPSoC helper
  static const Event MPSOC_SENDING_COMMAND_FAILED = MAKE_EVENT(2, severity::LOW);
  //! [EXPORT] : [COMMENT] Request receive message of communication interface failed
  //! P1: Return value returned by the communication interface requestReceiveMessage function
  //! P2: Internal state of MPSoC helper
  static const Event MPSOC_HELPER_REQUESTING_REPLY_FAILED = MAKE_EVENT(3, severity::LOW);
  //! [EXPORT] : [COMMENT] Reading receive message of communication interface failed
  //! P1: Return value returned by the communication interface readingReceivedMessage function
  //! P2: Internal state of MPSoC helper
  static const Event MPSOC_HELPER_READING_REPLY_FAILED = MAKE_EVENT(4, severity::LOW);
  //! [EXPORT] : [COMMENT] Did not receive acknowledgment report
  //! P1: Number of bytes missing
  //! P2: Internal state of MPSoC helper
  static const Event MPSOC_MISSING_ACK = MAKE_EVENT(5, severity::LOW);
  //! [EXPORT] : [COMMENT] Did not receive execution report
  //! P1: Number of bytes missing
  //! P2: Internal state of MPSoC helper
  static const Event MPSOC_MISSING_EXE = MAKE_EVENT(6, severity::LOW);
  //! [EXPORT] : [COMMENT] Received acknowledgment failure report
  //! P1: Internal state of MPSoC
  static const Event MPSOC_ACK_FAILURE_REPORT = MAKE_EVENT(7, severity::LOW);
  //! [EXPORT] : [COMMENT] Received execution failure report
  //! P1: Internal state of MPSoC
  static const Event MPSOC_EXE_FAILURE_REPORT = MAKE_EVENT(8, severity::LOW);
  //! [EXPORT] : [COMMENT] Expected acknowledgment report but received space packet with other apid
  //! P1: Apid of received space packet
  //! P2: Internal state of MPSoC
  static const Event MPSOC_ACK_INVALID_APID = MAKE_EVENT(9, severity::LOW);
  //! [EXPORT] : [COMMENT] Expected execution report but received space packet with other apid
  //! P1: Apid of received space packet
  //! P2: Internal state of MPSoC
  static const Event MPSOC_EXE_INVALID_APID = MAKE_EVENT(10, severity::LOW);
  //! [EXPORT] : [COMMENT] Received sequence count does not match expected sequence count
  //! P1: Expected sequence count
  //! P2: Received sequence count
  static const Event MPSOC_HELPER_SEQ_CNT_MISMATCH = MAKE_EVENT(11, severity::LOW);
  static const Event MPSOC_TM_SIZE_ERROR = MAKE_EVENT(12, severity::LOW);
  static const Event MPSOC_TM_CRC_MISSMATCH = MAKE_EVENT(13, severity::LOW);
  static const Event MPSOC_FLASH_READ_PACKET_ERROR = MAKE_EVENT(14, severity::LOW);
  static const Event MPSOC_FLASH_READ_FAILED = MAKE_EVENT(15, severity::LOW);
  static const Event MPSOC_FLASH_READ_SUCCESSFUL = MAKE_EVENT(16, severity::INFO);
  static const Event MPSOC_READ_TIMEOUT = MAKE_EVENT(17, severity::LOW);
  enum FlashReadErrorType : uint32_t {
    FLASH_READ_APID_ERROR = 0,
    FLASH_READ_FILENAME_ERROR = 1,
    FLASH_READ_READLEN_ERROR = 2
  };
  PlocMpsocSpecialComHelperLegacy(object_id_t objectId);
  virtual ~PlocMpsocSpecialComHelperLegacy();
  ReturnValue_t initialize() override;
  ReturnValue_t performOperation(uint8_t operationCode = 0) override;
  ReturnValue_t setComIF(DeviceCommunicationIF* communicationInterface_);
  void setComCookie(CookieIF* comCookie_);
  /**
   * @brief   Starts flash write sequence
   *
   * @param obcFile   File where to read from the data
   * @param mpsocFile The file of the MPSoC where should be written to
   *
   * @return  returnvalue::OK if successful, otherwise error return value
   */
  ReturnValue_t startFlashWrite(std::string obcFile, std::string mpsocFile);
  /**
   *
   * @param obcFile Full target file name on OBC
   * @param mpsocFile The file on the MPSoC which should be copied ot the OBC
   * @param readFileSize The size of the file on the MPSoC.
   * @return
   */
  ReturnValue_t startFlashRead(std::string obcFile, std::string mpsocFile, size_t readFileSize);
  /**
   * @brief   Can be used to interrupt a running data transfer.
   */
  void stopProcess();
  /**
   * @brief   Sets the sequence count object responsible for the sequence count handling
   */
  void setSequenceCount(SourceSequenceCounter* sequenceCount_);
 private:
  static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MPSOC_HELPER;
  //! [EXPORT] : [COMMENT] File error occured for file transfers from OBC to the MPSoC.
  static const ReturnValue_t FILE_WRITE_ERROR = MAKE_RETURN_CODE(0xA0);
  //! [EXPORT] : [COMMENT] File error occured for file transfers from MPSoC to OBC.
  static const ReturnValue_t FILE_READ_ERROR = MAKE_RETURN_CODE(0xA1);
  // Maximum number of times the communication interface retries polling data from the reply
  // buffer
  static const int RETRIES = 10000;
  struct FlashInfo {
    std::string obcFile;
    std::string mpsocFile;
  };
  struct FlashRead : public FlashInfo {
    size_t totalReadSize = 0;
  };
  struct FlashRead flashReadAndWrite;
 #if OBSW_THREAD_TRACING == 1
  uint32_t opCounter = 0;
 #endif
  enum class InternalState { IDLE, FLASH_WRITE, FLASH_READ };
  InternalState internalState = InternalState::IDLE;
  BinarySemaphore semaphore;
 #ifdef XIPHOS_Q7S
  SdCardManager* sdcMan = nullptr;
 #endif
  uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE];
  SpacePacketCreator creator;
  ploc::SpTcParams spParams = ploc::SpTcParams(creator);
  Countdown tmCountdown = Countdown(5000);
  std::array<uint8_t, mpsoc::SP_MAX_DATA_SIZE> fileBuf{};
  std::array<uint8_t, mpsoc::MAX_REPLY_SIZE> tmBuf{};
  bool terminate = false;
  /**
   * Communication interface of MPSoC responsible for low level access. Must be set by the
   * MPSoC Handler.
   */
  SerialComIF* uartComIF = nullptr;
  // Communication cookie. Must be set by the MPSoC Handler
  CookieIF* comCookie = nullptr;
  // Sequence count, must be set by Ploc MPSoC Handler
  SourceSequenceCounter* sequenceCount = nullptr;
  ploc::SpTmReader spReader;
  void resetHelper();
  ReturnValue_t performFlashWrite();
  ReturnValue_t performFlashRead();
  ReturnValue_t flashfopen(uint8_t accessMode);
  ReturnValue_t flashfclose();
  ReturnValue_t handlePacketTransmissionNoReply(ploc::SpTcBase& tc);
  ReturnValue_t handlePacketTransmissionFlashRead(mpsoc::TcFlashRead& tc, std::ofstream& ofile,
                                                  size_t expectedReadLen);
  ReturnValue_t handleFlashReadReply(std::ofstream& ofile, size_t expectedReadLen);
  ReturnValue_t sendCommand(ploc::SpTcBase& tc);
  ReturnValue_t receive(uint8_t* data, size_t requestBytes, size_t* readBytes);
  ReturnValue_t handleAck();
  ReturnValue_t handleExe();
  ReturnValue_t startFlashReadOrWriteBase(std::string obcFile, std::string mpsocFile);
  ReturnValue_t fileCheck(std::string obcFile);
  void handleAckApidFailure(const ploc::SpTmReader& reader);
  void handleExeFailure();
  ReturnValue_t handleTmReception();
  ReturnValue_t checkReceivedTm();
 };
 #endif /* BSP_Q7S_DEVICES_PLOCMPSOCHELPER_H_ */
--- a/bsp_hosted/CMakeLists.txt
+++ b/bsp_hosted/CMakeLists.txt
@ -1,4 +1,4 @@
-target_sources(${OBSW_NAME} PUBLIC scheduling.cpp main.cpp objectFactory.cpp)
+target_sources(${OBSW_NAME} PUBLIC scheduling.cpp main.cpp ObjectFactory.cpp)
 add_subdirectory(fsfwconfig)
 add_subdirectory(boardconfig)
--- a/bsp_hosted/OBSWConfig.h.in
+++ b/bsp_hosted/OBSWConfig.h.in
@ -48,7 +48,6 @@
 #define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    1
 #define OBSW_PRINT_MISSED_DEADLINES                 1
 #define OBSW_MPSOC_JTAG_BOOT                        0
 #define OBSW_SYRLINKS_SIMULATED                     1
 #define OBSW_ADD_TEST_CODE                          0
 #define OBSW_ADD_TEST_TASK                          0
@ -102,7 +101,7 @@
 /** CMake Defines                                                  */
 /*******************************************************************/
-#define OBSW_ADD_TMTC_UDP_SERVER            0
+#define OBSW_ADD_TMTC_UDP_SERVER            1
 #define OBSW_ADD_TMTC_TCP_SERVER            1
 #cmakedefine EIVE_BUILD_GPSD_GPS_HANDLER
--- a/bsp_hosted/ObjectFactory.cpp
+++ b/bsp_hosted/ObjectFactory.cpp
@ -1,4 +1,4 @@
-#include "objectFactory.h"
+#include "ObjectFactory.h"
 #include <fsfw/power/DummyPowerSwitcher.h>
 #include <fsfw/tmtcservices/CommandingServiceBase.h>
@ -38,7 +38,9 @@
 #include "devices/gpioIds.h"
 #include "fsfw_hal/linux/gpio/Gpio.h"
-#include "linux/payload/FreshSupvHandler.h"
+#include "linux/payload/PlocMpsocHandler.h"
 #include "linux/payload/PlocMpsocSpecialComHelper.h"
 #include "linux/payload/PlocSupervisorHandler.h"
 #include "linux/payload/PlocSupvUartMan.h"
 #include "test/gpio/DummyGpioIF.h"
 #endif
@ -59,14 +61,14 @@ void ObjectFactory::produce(void* args) {
  CfdpTmFunnel* cfdpFunnel;
  StorageManagerIF* tmStore;
  StorageManagerIF* ipcStore;
-  PersistentTmStores persistentStores{};
+  PersistentTmStores persistentStores;
  bool enableHkSets = false;
 #if OBSW_ENABLE_PERIODIC_HK == 1
  enableHkSets = true;
 #endif
  auto sdcMan = new DummySdCardManager("/tmp");
  ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel, *sdcMan, &ipcStore,
-                                       &tmStore, persistentStores, 120, enableHkSets, false);
+                                       &tmStore, persistentStores, 120, enableHkSets);
  new TmFunnelHandler(objects::LIVE_TM_TASK, *pusFunnel, *cfdpFunnel);
  auto* dummyGpioIF = new DummyGpioIF();
@ -77,10 +79,7 @@ void ObjectFactory::produce(void* args) {
    switcherList.emplace_back(initVal);
  }
  dummySwitcher->setInitialSwitcherList(switcherList);
 #ifdef PLATFORM_UNIX
  // Obsolete dev handler..
  /*
  new SerialComIF(objects::UART_COM_IF);
 #if OBSW_ADD_PLOC_MPSOC == 1
  std::string mpscoDev = "";
@ -91,25 +90,21 @@ void ObjectFactory::produce(void* args) {
  new PlocMpsocHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie,
                       plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, dummyGpioIF),
                       objects::PLOC_SUPERVISOR_HANDLER);
-#endif // OBSW_ADD_PLOC_MPSOC == 1
+#endif /* OBSW_ADD_PLOC_MPSOC == 1 */
  */
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
  std::string plocSupvString = "/dev/ploc_supv";
  auto supervisorCookie =
      new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER, plocSupvString, uart::PLOC_SUPV_BAUD,
                       supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
  supervisorCookie->setNoFixedSizeReply();
-  new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
+  auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
-  DhbConfig dhbConf(objects::PLOC_SUPERVISOR_HANDLER);
+  new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, supervisorCookie,
-  auto* supvHandler =
+                            Gpio(gpioIds::ENABLE_SUPV_UART, dummyGpioIF), pcdu::PDU1_CH6_PLOC_12V,
-      new FreshSupvHandler(dhbConf, supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, dummyGpioIF),
+                            *supvHelper);
                           dummySwitcher, power::PDU1_CH6_PLOC_12V);
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
 #endif
  dummy::DummyCfg cfg;
  cfg.addPlPcduDummy = true;
  cfg.addCamSwitcherDummy = true;
  dummy::createDummies(cfg, *dummySwitcher, dummyGpioIF, enableHkSets);
  HeaterHandler* heaterHandler = nullptr;
--- a/bsp_hosted/ObjectFactory.h
+++ b/bsp_hosted/ObjectFactory.h
--- a/bsp_hosted/fsfwconfig/events/translateEvents.cpp
+++ b/bsp_hosted/fsfwconfig/events/translateEvents.cpp
@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 325 translations.
+ * @brief    Auto-generated event translation file. Contains 304 translations.
 * @details
- * Generated on: 2024-05-06 13:47:38
+ * Generated on: 2023-08-21 15:54:29
 */
 #include "translateEvents.h"
@ -82,11 +82,8 @@ const char *BIT_LOCK_STRING = "BIT_LOCK";
 const char *BIT_LOCK_LOST_STRING = "BIT_LOCK_LOST";
 const char *FRAME_PROCESSING_FAILED_STRING = "FRAME_PROCESSING_FAILED";
 const char *CLOCK_SET_STRING = "CLOCK_SET";
 const char *CLOCK_DUMP_LEGACY_STRING = "CLOCK_DUMP_LEGACY";
 const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
 const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
-const char *CLOCK_DUMP_BEFORE_SETTING_TIME_STRING = "CLOCK_DUMP_BEFORE_SETTING_TIME";
+const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
 const char *CLOCK_DUMP_AFTER_SETTING_TIME_STRING = "CLOCK_DUMP_AFTER_SETTING_TIME";
 const char *TC_DELETION_FAILED_STRING = "TC_DELETION_FAILED";
 const char *TEST_STRING = "TEST";
 const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
@ -95,28 +92,19 @@ const char *MSG_QUEUE_ERROR_STRING = "MSG_QUEUE_ERROR";
 const char *SERIALIZATION_ERROR_STRING = "SERIALIZATION_ERROR";
 const char *FILESTORE_ERROR_STRING = "FILESTORE_ERROR";
 const char *FILENAME_TOO_LARGE_ERROR_STRING = "FILENAME_TOO_LARGE_ERROR";
 const char *HANDLING_CFDP_REQUEST_FAILED_STRING = "HANDLING_CFDP_REQUEST_FAILED";
 const char *SAFE_RATE_VIOLATION_STRING = "SAFE_RATE_VIOLATION";
-const char *RATE_RECOVERY_STRING = "RATE_RECOVERY";
+const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
 const char *MULTIPLE_RW_INVALID_STRING = "MULTIPLE_RW_INVALID";
 const char *MEKF_INVALID_INFO_STRING = "MEKF_INVALID_INFO";
 const char *MEKF_RECOVERY_STRING = "MEKF_RECOVERY";
 const char *MEKF_AUTOMATIC_RESET_STRING = "MEKF_AUTOMATIC_RESET";
-const char *PTG_CTRL_NO_ATTITUDE_INFORMATION_STRING = "PTG_CTRL_NO_ATTITUDE_INFORMATION";
+const char *MEKF_INVALID_MODE_VIOLATION_STRING = "MEKF_INVALID_MODE_VIOLATION";
 const char *SAFE_MODE_CONTROLLER_FAILURE_STRING = "SAFE_MODE_CONTROLLER_FAILURE";
 const char *TLE_TOO_OLD_STRING = "TLE_TOO_OLD";
 const char *TLE_FILE_READ_FAILED_STRING = "TLE_FILE_READ_FAILED";
 const char *PTG_RATE_VIOLATION_STRING = "PTG_RATE_VIOLATION";
 const char *DETUMBLE_TRANSITION_FAILED_STRING = "DETUMBLE_TRANSITION_FAILED";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
 const char *FDIR_REACTION_IGNORED_STRING = "FDIR_REACTION_IGNORED";
 const char *DATASET_READ_FAILED_STRING = "DATASET_READ_FAILED";
 const char *VOLTAGE_OUT_OF_BOUNDS_STRING = "VOLTAGE_OUT_OF_BOUNDS";
 const char *TIMEDELTA_OUT_OF_BOUNDS_STRING = "TIMEDELTA_OUT_OF_BOUNDS";
 const char *POWER_LEVEL_LOW_STRING = "POWER_LEVEL_LOW";
 const char *POWER_LEVEL_CRITICAL_STRING = "POWER_LEVEL_CRITICAL";
 const char *GPIO_PULL_HIGH_FAILED_STRING = "GPIO_PULL_HIGH_FAILED";
 const char *GPIO_PULL_LOW_FAILED_STRING = "GPIO_PULL_LOW_FAILED";
 const char *HEATER_WENT_ON_STRING = "HEATER_WENT_ON";
@ -140,9 +128,6 @@ const char *EXE_FAILURE_STRING = "EXE_FAILURE";
 const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE";
 const char *MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH";
 const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
 const char *SUPV_NOT_ON_STRING = "SUPV_NOT_ON";
 const char *SUPV_REPLY_TIMEOUT_STRING = "SUPV_REPLY_TIMEOUT";
 const char *CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE_STRING = "CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@ -164,8 +149,6 @@ const char *SUPV_EXE_FAILURE_STRING = "SUPV_EXE_FAILURE";
 const char *SUPV_CRC_FAILURE_EVENT_STRING = "SUPV_CRC_FAILURE_EVENT";
 const char *SUPV_HELPER_EXECUTING_STRING = "SUPV_HELPER_EXECUTING";
 const char *SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING = "SUPV_MPSOC_SHUTDOWN_BUILD_FAILED";
 const char *SUPV_ACK_UNKNOWN_COMMAND_STRING = "SUPV_ACK_UNKNOWN_COMMAND";
 const char *SUPV_EXE_ACK_UNKNOWN_COMMAND_STRING = "SUPV_EXE_ACK_UNKNOWN_COMMAND";
 const char *SANITIZATION_FAILED_STRING = "SANITIZATION_FAILED";
 const char *MOUNTED_SD_CARD_STRING = "MOUNTED_SD_CARD";
 const char *SEND_MRAM_DUMP_FAILED_STRING = "SEND_MRAM_DUMP_FAILED";
@ -245,7 +228,6 @@ const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903_STRING = "SIDE_SWITCH_TRANS
 const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
 const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
 const char *CANT_GET_FIX_STRING = "CANT_GET_FIX";
 const char *RESET_FAIL_STRING = "RESET_FAIL";
 const char *P60_BOOT_COUNT_STRING = "P60_BOOT_COUNT";
 const char *BATT_MODE_STRING = "BATT_MODE";
 const char *BATT_MODE_CHANGED_STRING = "BATT_MODE_CHANGED";
@ -327,9 +309,6 @@ const char *DUMP_NOK_CANCELLED_STRING = "DUMP_NOK_CANCELLED";
 const char *DUMP_MISC_CANCELLED_STRING = "DUMP_MISC_CANCELLED";
 const char *DUMP_HK_CANCELLED_STRING = "DUMP_HK_CANCELLED";
 const char *DUMP_CFDP_CANCELLED_STRING = "DUMP_CFDP_CANCELLED";
 const char *TEMPERATURE_ALL_ONES_START_STRING = "TEMPERATURE_ALL_ONES_START";
 const char *TEMPERATURE_ALL_ONES_RECOVERY_STRING = "TEMPERATURE_ALL_ONES_RECOVERY";
 const char *FAULT_HANDLER_TRIGGERED_STRING = "FAULT_HANDLER_TRIGGERED";
 const char *translateEvents(Event event) {
  switch ((event & 0xFFFF)) {
@ -488,15 +467,9 @@ const char *translateEvents(Event event) {
    case (8900):
      return CLOCK_SET_STRING;
    case (8901):
-      return CLOCK_DUMP_LEGACY_STRING;
+      return CLOCK_DUMP_STRING;
    case (8902):
      return CLOCK_SET_FAILURE_STRING;
    case (8903):
      return CLOCK_DUMP_STRING;
    case (8904):
      return CLOCK_DUMP_BEFORE_SETTING_TIME_STRING;
    case (8905):
      return CLOCK_DUMP_AFTER_SETTING_TIME_STRING;
    case (9100):
      return TC_DELETION_FAILED_STRING;
    case (9700):
@ -513,12 +486,10 @@ const char *translateEvents(Event event) {
      return FILESTORE_ERROR_STRING;
    case (10804):
      return FILENAME_TOO_LARGE_ERROR_STRING;
    case (10805):
      return HANDLING_CFDP_REQUEST_FAILED_STRING;
    case (11200):
      return SAFE_RATE_VIOLATION_STRING;
    case (11201):
-      return RATE_RECOVERY_STRING;
+      return SAFE_RATE_RECOVERY_STRING;
    case (11202):
      return MULTIPLE_RW_INVALID_STRING;
    case (11203):
@ -528,17 +499,11 @@ const char *translateEvents(Event event) {
    case (11205):
      return MEKF_AUTOMATIC_RESET_STRING;
    case (11206):
-      return PTG_CTRL_NO_ATTITUDE_INFORMATION_STRING;
+      return MEKF_INVALID_MODE_VIOLATION_STRING;
    case (11207):
      return SAFE_MODE_CONTROLLER_FAILURE_STRING;
    case (11208):
      return TLE_TOO_OLD_STRING;
    case (11209):
      return TLE_FILE_READ_FAILED_STRING;
    case (11210):
      return PTG_RATE_VIOLATION_STRING;
    case (11211):
      return DETUMBLE_TRANSITION_FAILED_STRING;
    case (11300):
      return SWITCH_CMD_SENT_STRING;
    case (11301):
@ -547,16 +512,6 @@ const char *translateEvents(Event event) {
      return SWITCHING_Q7S_DENIED_STRING;
    case (11303):
      return FDIR_REACTION_IGNORED_STRING;
    case (11304):
      return DATASET_READ_FAILED_STRING;
    case (11305):
      return VOLTAGE_OUT_OF_BOUNDS_STRING;
    case (11306):
      return TIMEDELTA_OUT_OF_BOUNDS_STRING;
    case (11307):
      return POWER_LEVEL_LOW_STRING;
    case (11308):
      return POWER_LEVEL_CRITICAL_STRING;
    case (11400):
      return GPIO_PULL_HIGH_FAILED_STRING;
    case (11401):
@ -603,12 +558,6 @@ const char *translateEvents(Event event) {
      return MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING;
    case (11606):
      return MPSOC_SHUTDOWN_FAILED_STRING;
    case (11607):
      return SUPV_NOT_ON_STRING;
    case (11608):
      return SUPV_REPLY_TIMEOUT_STRING;
    case (11609):
      return CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE_STRING;
    case (11701):
      return SELF_TEST_I2C_FAILURE_STRING;
    case (11702):
@ -651,10 +600,6 @@ const char *translateEvents(Event event) {
      return SUPV_HELPER_EXECUTING_STRING;
    case (12008):
      return SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING;
    case (12009):
      return SUPV_ACK_UNKNOWN_COMMAND_STRING;
    case (12010):
      return SUPV_EXE_ACK_UNKNOWN_COMMAND_STRING;
    case (12100):
      return SANITIZATION_FAILED_STRING;
    case (12101):
@ -813,8 +758,6 @@ const char *translateEvents(Event event) {
      return GPS_FIX_CHANGE_STRING;
    case (13101):
      return CANT_GET_FIX_STRING;
    case (13102):
      return RESET_FAIL_STRING;
    case (13200):
      return P60_BOOT_COUNT_STRING;
    case (13201):
@ -977,12 +920,6 @@ const char *translateEvents(Event event) {
      return DUMP_HK_CANCELLED_STRING;
    case (14314):
      return DUMP_CFDP_CANCELLED_STRING;
    case (14500):
      return TEMPERATURE_ALL_ONES_START_STRING;
    case (14501):
      return TEMPERATURE_ALL_ONES_RECOVERY_STRING;
    case (14600):
      return FAULT_HANDLER_TRIGGERED_STRING;
    default:
      return "UNKNOWN_EVENT";
  }
--- a/bsp_hosted/fsfwconfig/objects/translateObjects.cpp
+++ b/bsp_hosted/fsfwconfig/objects/translateObjects.cpp
@ -1,17 +1,15 @@
 /**
 * @brief  Auto-generated object translation file.
 * @details
- * Contains 176 translations.
+ * Contains 171 translations.
- * Generated on: 2024-05-06 13:47:38
+ * Generated on: 2023-08-21 15:54:29
 */
 #include "translateObjects.h"
 const char *TEST_TASK_STRING = "TEST_TASK";
 const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
 const char *CORE_CONTROLLER_STRING = "CORE_CONTROLLER";
 const char *POWER_CONTROLLER_STRING = "POWER_CONTROLLER";
 const char *GLOBAL_JSON_CFG_STRING = "GLOBAL_JSON_CFG";
 const char *XIPHOS_WDT_STRING = "XIPHOS_WDT";
 const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *DUMMY_HANDLER_STRING = "DUMMY_HANDLER";
 const char *MGM_0_LIS3_HANDLER_STRING = "MGM_0_LIS3_HANDLER";
@ -65,7 +63,6 @@ const char *PTME_VC3_CFDP_TM_STRING = "PTME_VC3_CFDP_TM";
 const char *PLOC_MPSOC_HANDLER_STRING = "PLOC_MPSOC_HANDLER";
 const char *PLOC_SUPERVISOR_HANDLER_STRING = "PLOC_SUPERVISOR_HANDLER";
 const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER";
 const char *PLOC_MPSOC_COMMUNICATION_STRING = "PLOC_MPSOC_COMMUNICATION";
 const char *SCEX_STRING = "SCEX";
 const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
 const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
@ -162,13 +159,11 @@ const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
 const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
 const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
 const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
 const char *CFDP_FAULT_HANDLER_STRING = "CFDP_FAULT_HANDLER";
 const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
 const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *TCS_SUBSYSTEM_STRING = "TCS_SUBSYSTEM";
 const char *COM_SUBSYSTEM_STRING = "COM_SUBSYSTEM";
 const char *EPS_SUBSYSTEM_STRING = "EPS_SUBSYSTEM";
 const char *MISC_TM_STORE_STRING = "MISC_TM_STORE";
 const char *OK_TM_STORE_STRING = "OK_TM_STORE";
 const char *NOT_OK_TM_STORE_STRING = "NOT_OK_TM_STORE";
@ -191,12 +186,8 @@ const char *translateObject(object_id_t object) {
      return ACS_CONTROLLER_STRING;
    case 0x43000003:
      return CORE_CONTROLLER_STRING;
    case 0x43000004:
      return POWER_CONTROLLER_STRING;
    case 0x43000006:
      return GLOBAL_JSON_CFG_STRING;
    case 0x43000007:
      return XIPHOS_WDT_STRING;
    case 0x43400001:
      return THERMAL_CONTROLLER_STRING;
    case 0x44000001:
@ -303,8 +294,6 @@ const char *translateObject(object_id_t object) {
      return PLOC_SUPERVISOR_HANDLER_STRING;
    case 0x44330017:
      return PLOC_SUPERVISOR_HELPER_STRING;
    case 0x44330018:
      return PLOC_MPSOC_COMMUNICATION_STRING;
    case 0x44330032:
      return SCEX_STRING;
    case 0x444100A2:
@ -497,8 +486,6 @@ const char *translateObject(object_id_t object) {
      return CFDP_HANDLER_STRING;
    case 0x73000206:
      return CFDP_DISTRIBUTOR_STRING;
    case 0x73000207:
      return CFDP_FAULT_HANDLER_STRING;
    case 0x73010000:
      return EIVE_SYSTEM_STRING;
    case 0x73010001:
@ -509,8 +496,6 @@ const char *translateObject(object_id_t object) {
      return TCS_SUBSYSTEM_STRING;
    case 0x73010004:
      return COM_SUBSYSTEM_STRING;
    case 0x73010005:
      return EPS_SUBSYSTEM_STRING;
    case 0x73020001:
      return MISC_TM_STORE_STRING;
    case 0x73020002:
--- a/bsp_hosted/scheduling.cpp
+++ b/bsp_hosted/scheduling.cpp
@ -13,8 +13,8 @@
 #include <iostream>
 #include "OBSWConfig.h"
 #include "ObjectFactory.h"
 #include "mission/scheduling.h"
 #include "objectFactory.h"
 #include "scheduling.h"
 #ifdef LINUX
@ -69,25 +69,21 @@ void scheduling::initTasks() {
  if (result != returnvalue::OK) {
    sif::error << "Adding CFDP distributor failed" << std::endl;
  }
 #if OBSW_ADD_TMTC_UDP_SERVER == 1
  result = tmtcDistributor->addComponent(objects::UDP_TMTC_SERVER);
  if (result != returnvalue::OK) {
    sif::error << "adding UDP server failed" << std::endl;
  }
 #endif
  result = tmtcDistributor->addComponent(objects::TCP_TMTC_SERVER);
  if (result != returnvalue::OK) {
    sif::error << "adding TCP server failed" << std::endl;
  }
 #if OBSW_ADD_TMTC_UDP_SERVER == 1
  PeriodicTaskIF* udpPollingTask = factory->createPeriodicTask(
      "UDP_POLLING", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
  result = udpPollingTask->addComponent(objects::UDP_TMTC_POLLING_TASK);
  if (result != returnvalue::OK) {
    sif::error << "Add component UDP Polling failed" << std::endl;
  }
 #endif
  PeriodicTaskIF* tcpPollingTask = factory->createPeriodicTask(
      "TCP_POLLING", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE, 2.0, missedDeadlineFunc);
  result = tcpPollingTask->addComponent(objects::TCP_TMTC_POLLING_TASK);
@ -96,7 +92,7 @@ void scheduling::initTasks() {
  }
  PeriodicTaskIF* liveTmTask = factory->createPeriodicTask(
-      "LIVE_TM", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, nullptr, &RR_SCHEDULING);
+      "LIVE_TM", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, nullptr, &RR_SCHEDULING);
  result = liveTmTask->addComponent(objects::LIVE_TM_TASK);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("LIVE_TM", objects::LIVE_TM_TASK);
@ -183,28 +179,6 @@ void scheduling::initTasks() {
  }
 #endif
  // If those are added at a later stage..
  /*
  PeriodicTaskIF* logTmTask = factory->createPeriodicTask(
      "LOG_PSTORE", 0, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, nullptr);
  result = logTmTask->addComponent(objects::LOG_STORE_AND_TM_TASK);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("LOG_STORE_AND_TM", objects::LOG_STORE_AND_TM_TASK);
  }
  PeriodicTaskIF* hkTmTask =
      factory->createPeriodicTask("HK_PSTORE", 0, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, nullptr);
  result = hkTmTask->addComponent(objects::HK_STORE_AND_TM_TASK);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("HK_STORE_AND_TM", objects::HK_STORE_AND_TM_TASK);
  }
  PeriodicTaskIF* cfdpTmTask = factory->createPeriodicTask(
      "CFDP_PSTORE", 0, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, nullptr);
  result = cfdpTmTask->addComponent(objects::CFDP_STORE_AND_TM_TASK);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("CFDP_STORE_AND_TM", objects::CFDP_STORE_AND_TM_TASK);
  }
   */
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
  PeriodicTaskIF* supvHelperTask = factory->createPeriodicTask(
      "PLOC_SUPV_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
@ -227,7 +201,7 @@ void scheduling::initTasks() {
  PeriodicTaskIF* dummyTask = factory->createPeriodicTask(
      "DUMMY_TASK", 35, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
  dummyTask->addComponent(objects::THERMAL_TEMP_INSERTER);
-  scheduling::scheduleTmpTempSensors(dummyTask, true);
+  scheduling::scheduleTmpTempSensors(dummyTask);
  scheduling::scheduleRtdSensors(dummyTask);
  dummyTask->addComponent(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
  dummyTask->addComponent(objects::SUS_1_N_LOC_XBYFZM_PT_XB);
@ -244,9 +218,7 @@ void scheduling::initTasks() {
  sif::info << "Starting tasks.." << std::endl;
  tmtcDistributor->startTask();
 #if OBSW_ADD_TMTC_UDP_SERVER == 1
  udpPollingTask->startTask();
 #endif
  tcpPollingTask->startTask();
  liveTmTask->startTask();
@ -256,12 +228,6 @@ void scheduling::initTasks() {
  pstTask->startTask();
  thermalTask->startTask();
  dummyTask->startTask();
  // If those are added at a later stage..
  // logTmTask->startTask();
  // cfdpTmTask->startTask();
  // hkTmTask->startTask();
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
  supvHelperTask->startTask();
 #endif
--- a/bsp_q7s/CMakeLists.txt
+++ b/bsp_q7s/CMakeLists.txt
@ -25,4 +25,3 @@ add_subdirectory(memory)
 add_subdirectory(callbacks)
 add_subdirectory(xadc)
 add_subdirectory(fs)
 add_subdirectory(acs)
--- a/bsp_q7s/acs/CMakeLists.txt
+++ b/bsp_q7s/acs/CMakeLists.txt
@ -1 +0,0 @@
 # target_sources(${OBSW_NAME} PUBLIC <Source File List>)
--- a/bsp_q7s/acs/StrConfigPathGetter.h
+++ b/bsp_q7s/acs/StrConfigPathGetter.h
@ -1,23 +0,0 @@
 #include <optional>
 #include "bsp_q7s/fs/SdCardManager.h"
 #include "mission/acs/str/strHelpers.h"
 class StrConfigPathGetter : public startracker::SdCardConfigPathGetter {
 public:
  StrConfigPathGetter(SdCardManager& sdcMan) : sdcMan(sdcMan) {}
  std::optional<std::string> getCfgPath() override {
    if (!sdcMan.isSdCardUsable(std::nullopt)) {
      return std::nullopt;
    }
    if (sdcMan.getActiveSdCard() == sd::SdCard::SLOT_1) {
      return std::string("/mnt/sd1/startracker/flight-config.json");
    } else {
      return std::string("/mnt/sd0/startracker/flight-config.json");
    }
  }
 private:
  SdCardManager& sdcMan;
 };
--- a/bsp_q7s/boardconfig/busConf.h
+++ b/bsp_q7s/boardconfig/busConf.h
@ -18,8 +18,7 @@ static constexpr char I2C_Q7_EIVE[] = "/dev/i2c_q7";
 static constexpr char UART_GNSS_DEV[] = "/dev/gps0";
 static constexpr char UART_PLOC_MPSOC_DEV[] = "/dev/ul_plmpsoc";
-static constexpr char UART_PLOC_SUPERVISOR_DEV_FALLBACK[] = "/dev/ttyUL4";
+static constexpr char UART_PLOC_SUPERVSIOR_DEV[] = "/dev/ploc_supv";
 static constexpr char UART_PLOC_SUPERVISOR_DEV[] = "/dev/ploc_supv";
 static constexpr char UART_SYRLINKS_DEV[] = "/dev/ul_syrlinks";
 static constexpr char UART_STAR_TRACKER_DEV[] = "/dev/ul_str";
 static constexpr char UART_SCEX_DEV[] = "/dev/scex";
--- a/bsp_q7s/core/CMakeLists.txt
+++ b/bsp_q7s/core/CMakeLists.txt
@ -1,2 +1 @@
-target_sources(${OBSW_NAME} PRIVATE CoreController.cpp WatchdogHandler.cpp
+target_sources(${OBSW_NAME} PRIVATE CoreController.cpp WatchdogHandler.cpp)
                                    XiphosWdtHandler.cpp)
--- a/bsp_q7s/core/CoreController.cpp
+++ b/bsp_q7s/core/CoreController.cpp
@ -480,16 +480,6 @@ ReturnValue_t CoreController::executeAction(ActionId_t actionId, MessageQueueId_
      successRecipient = commandedBy;
      return returnvalue::OK;
    }
    case (UPDATE_LEAP_SECONDS): {
      if (size != sizeof(uint16_t)) {
        return HasActionsIF::INVALID_PARAMETERS;
      }
      ReturnValue_t result = actionUpdateLeapSeconds(data);
      if (result != returnvalue::OK) {
        return result;
      }
      return HasActionsIF::EXECUTION_FINISHED;
    }
    default: {
      return HasActionsIF::INVALID_ACTION_ID;
    }
@ -1421,9 +1411,6 @@ void CoreController::performMountedSdCardOperations() {
      if (not timeFileInitDone) {
        initClockFromTimeFile();
      }
      if (not leapSecondsInitDone) {
        initLeapSeconds();
      }
      performRebootWatchdogHandling(false);
      performRebootCountersHandling(false);
    }
@ -2079,78 +2066,14 @@ ReturnValue_t CoreController::backupTimeFileHandler() {
  return returnvalue::OK;
 }
 void CoreController::initLeapSeconds() {
  ReturnValue_t result = initLeapSecondsFromFile();
  if (result != returnvalue::OK) {
    Clock::setLeapSeconds(config::LEAP_SECONDS);
    writeLeapSecondsToFile(config::LEAP_SECONDS);
  }
  leapSecondsInitDone = true;
 }
 ReturnValue_t CoreController::initLeapSecondsFromFile() {
  std::string fileName = currMntPrefix + LEAP_SECONDS_FILE;
  std::error_code e;
  if (sdcMan->isSdCardUsable(std::nullopt) and std::filesystem::exists(fileName, e)) {
    std::ifstream leapSecondsFile(fileName);
    std::string nextWord;
    std::getline(leapSecondsFile, nextWord);
    std::istringstream iss(nextWord);
    iss >> nextWord;
    if (iss.bad() or nextWord != "LEAP") {
      return returnvalue::FAILED;
    }
    iss >> nextWord;
    if (iss.bad() or nextWord != "SECONDS:") {
      return returnvalue::FAILED;
    }
    iss >> nextWord;
    uint16_t leapSeconds = 0;
    leapSeconds = std::stoi(nextWord.c_str());
    if (iss.bad()) {
      return returnvalue::FAILED;
    }
    Clock::setLeapSeconds(leapSeconds);
    return returnvalue::OK;
  }
  sif::error
      << "CoreController::leapSecondsFileHandler: Initalization of leap seconds from file failed"
      << std::endl;
  return returnvalue::FAILED;
 };
 ReturnValue_t CoreController::writeLeapSecondsToFile(const uint16_t leapSeconds) {
  std::string fileName = currMntPrefix + LEAP_SECONDS_FILE;
  if (not sdcMan->isSdCardUsable(std::nullopt)) {
    return returnvalue::FAILED;
  }
  std::ofstream leapSecondsFile(fileName.c_str(), std::ofstream::out | std::ofstream::trunc);
  if (not leapSecondsFile.good()) {
    sif::error << "CoreController::leapSecondsFileHandler: Error opening leap seconds file: "
               << strerror(errno) << std::endl;
    return returnvalue::FAILED;
  }
  leapSecondsFile << "LEAP SECONDS: " << leapSeconds << std::endl;
  return returnvalue::OK;
 };
 ReturnValue_t CoreController::actionUpdateLeapSeconds(const uint8_t *data) {
  uint16_t leapSeconds = data[1] | (data[0] << 8);
  ReturnValue_t result = writeLeapSecondsToFile(leapSeconds);
  if (result != returnvalue::OK) {
    return result;
  }
  Clock::setLeapSeconds(leapSeconds);
  return returnvalue::OK;
 }
 ReturnValue_t CoreController::initClockFromTimeFile() {
  using namespace GpsHyperion;
  using namespace std;
  std::string fileName = currMntPrefix + BACKUP_TIME_FILE;
  std::error_code e;
  if (sdcMan->isSdCardUsable(std::nullopt) and std::filesystem::exists(fileName, e) and
-      ((gpsFix == FixMode::NOT_SEEN) or not utility::timeSanityCheck())) {
+      ((gpsFix == FixMode::UNKNOWN or gpsFix == FixMode::NOT_SEEN) or
       not utility::timeSanityCheck())) {
    ifstream timeFile(fileName);
    string nextWord;
    getline(timeFile, nextWord);
--- a/bsp_q7s/core/CoreController.h
+++ b/bsp_q7s/core/CoreController.h
@ -9,7 +9,7 @@
 #include <fsfw/parameters/ReceivesParameterMessagesIF.h>
 #include <fsfw_hal/linux/uio/UioMapper.h>
 #include <libxiphos.h>
-#include <linux/acs/GPSDefinitions.h>
+#include <mission/acs/archive/GPSDefinitions.h>
 #include <mission/utility/trace.h>
 #include <atomic>
@ -150,8 +150,6 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
      std::string(core::LEGACY_REBOOT_WATCHDOG_FILE_NAME);
  const std::string REBOOT_WATCHDOG_FILE =
      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::REBOOT_WATCHDOG_FILE_NAME);
  const std::string LEAP_SECONDS_FILE =
      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::LEAP_SECONDS_FILE_NAME);
  const std::string BACKUP_TIME_FILE =
      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::TIME_FILE_NAME);
  const std::string REBOOT_COUNTERS_FILE =
@ -211,7 +209,7 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
  static constexpr MutexIF::TimeoutType TIMEOUT_TYPE = MutexIF::TimeoutType::WAITING;
  static constexpr uint32_t MUTEX_TIMEOUT = 20;
  bool enableHkSet = false;
-  GpsHyperion::FixMode gpsFix = GpsHyperion::FixMode::NOT_SEEN;
+  GpsHyperion::FixMode gpsFix = GpsHyperion::FixMode::UNKNOWN;
  // States for SD state machine, which is used in non-blocking mode
  enum class SdStates {
@ -298,7 +296,6 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
  std::string currMntPrefix;
  bool timeFileInitDone = false;
  bool leapSecondsInitDone = false;
  bool performOneShotSdCardOpsSwitch = false;
  uint8_t shortSdCardCdCounter = 0;
 #if OBSW_THREAD_TRACING == 1
@ -338,11 +335,7 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
  void performMountedSdCardOperations();
  ReturnValue_t initVersionFile();
  void initLeapSeconds();
  ReturnValue_t initLeapSecondsFromFile();
  ReturnValue_t initClockFromTimeFile();
  ReturnValue_t actionUpdateLeapSeconds(const uint8_t* data);
  ReturnValue_t writeLeapSecondsToFile(const uint16_t leapSeconds);
  ReturnValue_t performSdCardCheck();
  ReturnValue_t backupTimeFileHandler();
  ReturnValue_t initBootCopyFile();
--- a/bsp_q7s/core/XiphosWdtHandler.cpp
+++ b/bsp_q7s/core/XiphosWdtHandler.cpp
@ -1,122 +0,0 @@
 #include "XiphosWdtHandler.h"
 #include "fsfw/ipc/QueueFactory.h"
 XiphosWdtHandler::XiphosWdtHandler(object_id_t objectId)
    : SystemObject(objectId),
      requestQueue(QueueFactory::instance()->createMessageQueue()),
      actionHelper(this, requestQueue) {}
 ReturnValue_t XiphosWdtHandler::initialize() {
  ReturnValue_t result = actionHelper.initialize();
  if (result != returnvalue::OK) {
    return result;
  }
  int retval = xsc_watchdog_init(&wdtHandle);
  if (retval != 0) {
    sif::error << "XiphosWdtHandler: Initiating watchdog failed with code " << retval << ": "
               << strerror(retval) << std::endl;
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
  if (wdtHandle == nullptr) {
    sif::error << "XiphosWdtHandler: WDT handle is nullptr!" << std::endl;
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
  retval = xsc_watchdog_set_timeout(wdtHandle, timeoutSeconds);
  if (retval != 0) {
    // This propably means that the default timeout is used. Still continue with task init.
    sif::warning << "XiphosWdtHandler: Setting WDT timeout of " << timeoutSeconds
                 << " seconds failed with code " << result << ": " << strerror(retval) << std::endl;
  }
  return enableWdt();
 }
 ReturnValue_t XiphosWdtHandler::performOperation(uint8_t opCode) {
  CommandMessage command;
  ReturnValue_t result;
  for (result = requestQueue->receiveMessage(&command); result == returnvalue::OK;
       result = requestQueue->receiveMessage(&command)) {
    result = actionHelper.handleActionMessage(&command);
    if (result == returnvalue::OK) {
      continue;
    }
    sif::warning << "Can not handle message with message type " << command.getMessageType()
                 << std::endl;
  }
  if (enabled) {
    int retval = xsc_watchdog_keepalive(wdtHandle);
    if (retval != 0) {
      sif::warning << "XiphosWdtHandler: Feeding WDT failed with code " << retval << ": "
                   << strerror(retval) << std::endl;
      return returnvalue::FAILED;
    }
  }
  return returnvalue::OK;
 }
 ReturnValue_t XiphosWdtHandler::executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                                              const uint8_t *data, size_t size) {
  switch (actionId) {
    case (ActionId::ENABLE): {
      ReturnValue_t result = enableWdt();
      if (result != returnvalue::OK) {
        return result;
      }
      return EXECUTION_FINISHED;
    }
    case (ActionId::DISABLE): {
      ReturnValue_t result = disableWdt();
      if (result != returnvalue::OK) {
        return result;
      }
      return EXECUTION_FINISHED;
    }
  }
  return HasActionsIF::INVALID_ACTION_ID;
 }
 ReturnValue_t XiphosWdtHandler::enableWdt() {
  int nowayout = 0;
  int status = 0;
  int retval = xsc_watchdog_get_status(&nowayout, &status);
  // If this fails for whatever reason, just try enabling in any case.
  if (retval != 0) {
    sif::warning << "XiphosWdtHandler: Getting WDT status failed" << std::endl;
  }
  // Of course the enable API will fail if the device is already on, just perfect, love me some
  // good C API... :)))
  if (retval != 0 or status == 0) {
    retval = xsc_watchdog_enable(wdtHandle);
    if (retval != 0) {
      sif::error << "XiphosWdtHandler: Enabling WDT failed with code " << retval << ": "
                 << strerror(retval) << std::endl;
      return returnvalue::FAILED;
    }
  }
  enabled = true;
  return returnvalue::OK;
 }
 ReturnValue_t XiphosWdtHandler::disableWdt() {
  int nowayout = 0;
  int status = 0;
  int retval = xsc_watchdog_get_status(&nowayout, &status);
  // If this fails for whatever reason, just try disabling in any case.
  if (retval != 0) {
    sif::warning << "XiphosWdtHandler: Getting WDT status failed" << std::endl;
  }
  // Of course the disable API will fail if the device is already off, just perfect, love me some
  // good C API... :)))
  if (retval != 0 or status == 1) {
    retval = xsc_watchdog_disable(wdtHandle);
    if (retval != 0) {
      sif::error << "XiphosWdtHandler: Disabling WDT failed with code " << retval << ": "
                 << strerror(retval) << std::endl;
      return returnvalue::FAILED;
    }
  }
  enabled = false;
  return returnvalue::OK;
 }
 MessageQueueId_t XiphosWdtHandler::getCommandQueue() const { return requestQueue->getId(); }
--- a/bsp_q7s/core/XiphosWdtHandler.h
+++ b/bsp_q7s/core/XiphosWdtHandler.h
@ -1,36 +0,0 @@
 #ifndef BSP_Q7S_CORE_XIPHOSWDTHANDLER_H_
 #define BSP_Q7S_CORE_XIPHOSWDTHANDLER_H_
 #include <fsfw/action/HasActionsIF.h>
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw/tasks/ExecutableObjectIF.h>
 #include <libxiphos.h>
 class XiphosWdtHandler : public SystemObject, public ExecutableObjectIF, public HasActionsIF {
 public:
  enum ActionId { ENABLE = 0, DISABLE = 1 };
  XiphosWdtHandler(object_id_t objectId);
  ReturnValue_t performOperation(uint8_t opCode) override;
  ReturnValue_t initialize() override;
  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                              const uint8_t* data, size_t size) override;
  [[nodiscard]] virtual MessageQueueId_t getCommandQueue() const override;
 private:
  // Wrappers to ensure idempotency of trash C API.
  ReturnValue_t enableWdt();
  ReturnValue_t disableWdt();
  // Timeout duration range specified by Xiphos: 0.001 seconds to 171 seconds. The libxiphos API
  // expects an int, so I guess this translates to 1 to 171 seconds.
  // WARNING: DO NOT SET THIS HIGHER THAN 80 SECONDS!
  // Possible bug in Xiphos/Xilinx kernel driver for watchdog, related to overflow.
  int timeoutSeconds = 80;
  bool enabled = false;
  struct watchdog_s* wdtHandle = nullptr;
  MessageQueueIF* requestQueue = nullptr;
  ActionHelper actionHelper;
 };
 #endif /* BSP_Q7S_CORE_XIPHOSWDTHANDLER_H_ */
--- a/bsp_q7s/em/emObjectFactory.cpp
+++ b/bsp_q7s/em/emObjectFactory.cpp
@ -1,5 +1,4 @@
 #include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
 #include <bsp_q7s/core/XiphosWdtHandler.h>
 #include <bsp_q7s/objectFactory.h>
 #include <dummies/ComCookieDummy.h>
 #include <dummies/PcduHandlerDummy.h>
@ -38,10 +37,9 @@ void ObjectFactory::produce(void* args) {
  PersistentTmStores stores;
  readFirmwareVersion();
  new XiphosWdtHandler(objects::XIPHOS_WDT);
  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores, 200,
-                                       enableHkSets, true);
+                                       enableHkSets);
  LinuxLibgpioIF* gpioComIF = nullptr;
  SerialComIF* uartComIF = nullptr;
@ -108,17 +106,6 @@ void ObjectFactory::produce(void* args) {
 #endif
  satsystem::EIVE_SYSTEM.setI2cRecoveryParams(pwrSwitcher);
  const char* battAndImtqI2cDev = q7s::I2C_PL_EIVE;
  if (core::FW_VERSION_MAJOR >= 4) {
    battAndImtqI2cDev = q7s::I2C_PS_EIVE;
  }
  static_cast<void>(battAndImtqI2cDev);
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
  createBpxBatteryComponent(enableHkSets, battAndImtqI2cDev);
 #endif
  createPowerController(true, enableHkSets);
  dummy::createDummies(dummyCfg, *pwrSwitcher, gpioComIF, enableHkSets);
  new CoreController(objects::CORE_CONTROLLER, enableHkSets);
@ -139,6 +126,12 @@ void ObjectFactory::produce(void* args) {
  gpioChecker(gpioComIF->addGpios(acsBoardGpios), "ACS Board");
 #endif
  const char* battAndImtqI2cDev = q7s::I2C_PL_EIVE;
  if (core::FW_VERSION_MAJOR >= 4) {
    battAndImtqI2cDev = q7s::I2C_PS_EIVE;
  }
  static_cast<void>(battAndImtqI2cDev);
 #if OBSW_ADD_MGT == 1
  createImtqComponents(pwrSwitcher, enableHkSets, battAndImtqI2cDev);
 #endif
@ -151,8 +144,12 @@ void ObjectFactory::produce(void* args) {
  createReactionWheelComponents(gpioComIF, pwrSwitcher);
 #endif
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
  createBpxBatteryComponent(enableHkSets, battAndImtqI2cDev);
 #endif
 #if OBSW_ADD_STAR_TRACKER == 1
-  createStrComponents(pwrSwitcher, *SdCardManager::instance());
+  createStrComponents(pwrSwitcher);
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 #if OBSW_ADD_PL_PCDU == 1
@ -163,10 +160,15 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_CCSDS_IP_CORES == 1
  CcsdsIpCoreHandler* ipCoreHandler = nullptr;
  CcsdsComponentArgs ccsdsArgs(*gpioComIF, *ipcStore, *tmStore, stores, *pusFunnel, *cfdpFunnel,
-                               &ipCoreHandler, 0, 0);
+                               &ipCoreHandler);
-  createCcsdsIpComponentsWrapper(ccsdsArgs);
+  createCcsdsComponents(ccsdsArgs);
 #if OBSW_TM_TO_PTME == 1
  if (ccsdsArgs.liveDestination != nullptr) {
    pusFunnel->addLiveDestination("VC0 LIVE TM", *ccsdsArgs.liveDestination, 0);
    cfdpFunnel->addLiveDestination("VC0 LIVE TM", *ccsdsArgs.liveDestination, 0);
  }
 #endif
 #endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
  /* Test Task */
 #if OBSW_ADD_TEST_CODE == 1
  createTestComponents(gpioComIF);
@ -175,7 +177,7 @@ void ObjectFactory::produce(void* args) {
  createScexComponents(q7s::UART_SCEX_DEV, pwrSwitcher, *SdCardManager::instance(), false,
                       power::Switches::PDU1_CH5_SOLAR_CELL_EXP_5V);
 #endif
-  createAcsController(true, enableHkSets, *SdCardManager::instance());
+  createAcsController(true, enableHkSets);
  HeaterHandler* heaterHandler;
  createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
  createThermalController(*heaterHandler, true);
--- a/bsp_q7s/fmObjectFactory.cpp
+++ b/bsp_q7s/fmObjectFactory.cpp
@ -1,5 +1,4 @@
 #include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
 #include <bsp_q7s/core/XiphosWdtHandler.h>
 #include <bsp_q7s/objectFactory.h>
 #include <devices/gpioIds.h>
 #include <fsfw/storagemanager/LocalPool.h>
@ -35,10 +34,9 @@ void ObjectFactory::produce(void* args) {
  PersistentTmStores stores;
  readFirmwareVersion();
  new XiphosWdtHandler(objects::XIPHOS_WDT);
  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores, 200,
-                                       true, true);
+                                       true);
  LinuxLibgpioIF* gpioComIF = nullptr;
  SerialComIF* uartComIF = nullptr;
@ -83,6 +81,14 @@ void ObjectFactory::produce(void* args) {
  createTmpComponents(tmpDevsToAdd);
 #endif
  createSolarArrayDeploymentComponents(*pwrSwitcher, *gpioComIF);
 #if OBSW_ADD_PL_PCDU == 1
  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher, *stackHandler);
 #endif
 #if OBSW_ADD_SYRLINKS == 1
  createSyrlinksComponents(pwrSwitcher);
 #endif /* OBSW_ADD_SYRLINKS == 1 */
  createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
  createPayloadComponents(gpioComIF, *pwrSwitcher);
  const char* battAndImtqI2cDev = q7s::I2C_PL_EIVE;
  if (core::FW_VERSION_MAJOR >= 4) {
@ -96,27 +102,22 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
  createBpxBatteryComponent(enableHkSets, battAndImtqI2cDev);
 #endif
  createPowerController(true, enableHkSets);
 #if OBSW_ADD_PL_PCDU == 1
  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher, *stackHandler);
 #endif
 #if OBSW_ADD_SYRLINKS == 1
  createSyrlinksComponents(pwrSwitcher);
 #endif /* OBSW_ADD_SYRLINKS == 1 */
  createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
  createPayloadComponents(gpioComIF, *pwrSwitcher);
 #if OBSW_ADD_STAR_TRACKER == 1
-  createStrComponents(pwrSwitcher, *SdCardManager::instance());
+  createStrComponents(pwrSwitcher);
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
 #if OBSW_ADD_CCSDS_IP_CORES == 1
  CcsdsIpCoreHandler* ipCoreHandler = nullptr;
  CcsdsComponentArgs ccsdsArgs(*gpioComIF, *ipcStore, *tmStore, stores, *pusFunnel, *cfdpFunnel,
-                               &ipCoreHandler, 0, 0);
+                               &ipCoreHandler);
-  createCcsdsIpComponentsWrapper(ccsdsArgs);
+  createCcsdsComponents(ccsdsArgs);
 #if OBSW_TM_TO_PTME == 1
  if (ccsdsArgs.liveDestination != nullptr) {
    pusFunnel->addLiveDestination("VC0 LIVE TM", *ccsdsArgs.liveDestination, 0);
    cfdpFunnel->addLiveDestination("VC0 LIVE TM", *ccsdsArgs.liveDestination, 0);
  }
 #endif
 #endif /* OBSW_ADD_CCSDS_IP_CORES == 1 */
 #if OBSW_ADD_SCEX_DEVICE == 1
@ -130,6 +131,6 @@ void ObjectFactory::produce(void* args) {
  createMiscComponents();
  createThermalController(*heaterHandler, false);
-  createAcsController(true, enableHkSets, *SdCardManager::instance());
+  createAcsController(true, enableHkSets);
  satsystem::init(false);
 }
--- a/bsp_q7s/objectFactory.cpp
+++ b/bsp_q7s/objectFactory.cpp
@ -10,10 +10,10 @@
 #include <linux/acs/RwPollingTask.h>
 #include <linux/acs/StrComHandler.h>
 #include <linux/com/SyrlinksComHandler.h>
 #include <linux/payload/FreshMpsocHandler.h>
 #include <linux/payload/MpsocCommunication.h>
 #include <linux/payload/PlocMemoryDumper.h>
 #include <linux/payload/PlocMpsocHandler.h>
 #include <linux/payload/PlocMpsocSpecialComHelper.h>
 #include <linux/payload/PlocSupervisorHandler.h>
 #include <linux/payload/ScexUartReader.h>
 #include <linux/payload/plocMpsocHelpers.h>
 #include <linux/power/CspComIF.h>
@ -37,10 +37,11 @@
 #include <cstring>
 #include "OBSWConfig.h"
 #include "bsp_q7s/acs/StrConfigPathGetter.h"
 #include "bsp_q7s/boardtest/Q7STestTask.h"
 #include "bsp_q7s/callbacks/gnssCallback.h"
 #include "bsp_q7s/callbacks/pcduSwitchCb.h"
 #include "bsp_q7s/callbacks/q7sGpioCallbacks.h"
 #include "bsp_q7s/callbacks/rwSpiCallback.h"
 #include "busConf.h"
 #include "ccsdsConfig.h"
 #include "devConf.h"
@ -48,7 +49,6 @@
 #include "devices/gpioIds.h"
 #include "devices/powerSwitcherList.h"
 #include "eive/definitions.h"
 #include "eive/objects.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "linux/ObjectFactory.h"
 #include "linux/boardtest/I2cTestClass.h"
@ -60,12 +60,7 @@
 #include "linux/ipcore/PdecHandler.h"
 #include "linux/ipcore/Ptme.h"
 #include "linux/ipcore/PtmeConfig.h"
 #include "linux/payload/FreshSupvHandler.h"
 #include "linux/payload/MpsocCommunication.h"
 #include "linux/payload/PlocMpsocSpecialComHelper.h"
 #include "linux/payload/SerialConfig.h"
 #include "mission/config/configfile.h"
 #include "mission/power/defs.h"
 #include "mission/system/acs/AcsBoardFdir.h"
 #include "mission/system/acs/AcsSubsystem.h"
 #include "mission/system/acs/RwAssembly.h"
@ -73,11 +68,11 @@
 #include "mission/system/acs/acsModeTree.h"
 #include "mission/system/com/SyrlinksFdir.h"
 #include "mission/system/com/comModeTree.h"
 #include "mission/system/payload/payloadModeTree.h"
 #include "mission/system/power/GomspacePowerFdir.h"
 #include "mission/system/tcs/RtdFdir.h"
 #include "mission/system/tcs/TcsBoardAssembly.h"
 #include "mission/system/tcs/tcsModeTree.h"
 #include "mission/system/tree/payloadModeTree.h"
 #include "mission/tmtc/tmFilters.h"
 #include "mission/utility/GlobalConfigHandler.h"
 #include "tmtc/pusIds.h"
@ -139,7 +134,7 @@ using gpio::Levels;
 ResetArgs RESET_ARGS_GNSS;
 std::atomic_bool LINK_STATE = CcsdsIpCoreHandler::LINK_DOWN;
 std::atomic_bool PTME_LOCKED = false;
-std::atomic_uint16_t signals::I2C_FATAL_ERRORS = 0;
+std::atomic_uint16_t I2C_FATAL_ERRORS = 0;
 uint8_t core::FW_VERSION_MAJOR = 0;
 uint8_t core::FW_VERSION_MINOR = 0;
 uint8_t core::FW_VERSION_REVISION = 0;
@ -516,7 +511,7 @@ void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF*
  debugGps = true;
 #endif
  RESET_ARGS_GNSS.gpioComIF = gpioComIF;
-  RESET_ARGS_GNSS.waitPeriodMs = 10 * 1e3;
+  RESET_ARGS_GNSS.waitPeriodMs = 5;
  auto gpsCtrl = new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT,
                                                enableHkSets, debugGps);
  gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);
@ -617,11 +612,11 @@ void ObjectFactory::createSyrlinksComponents(PowerSwitchIF* pwrSwitcher) {
 #endif
 }
-void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF& pwrSwitcher) {
+void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF& pwrSwitch) {
  using namespace gpio;
  std::stringstream consumer;
  auto* camSwitcher =
-      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitcher, power::PDU2_CH8_PAYLOAD_CAMERA);
+      new CamSwitcher(objects::CAM_SWITCHER, pwrSwitch, power::PDU2_CH8_PAYLOAD_CAMERA);
  camSwitcher->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 #if OBSW_ADD_PLOC_MPSOC == 1
  consumer << "0x" << std::hex << objects::PLOC_MPSOC_HANDLER;
@ -630,15 +625,14 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
  auto mpsocGpioCookie = new GpioCookie;
  mpsocGpioCookie->addGpio(gpioIds::ENABLE_MPSOC_UART, gpioConfigMPSoC);
  gpioChecker(gpioComIF->addGpios(mpsocGpioCookie), "PLOC MPSoC");
-  SerialConfig serialCfg(q7s::UART_PLOC_MPSOC_DEV, serial::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE,
+  auto mpsocCookie =
-                         UartModes::NON_CANONICAL);
+      new SerialCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV,
-  auto mpsocCommunication = new MpsocCommunication(objects::PLOC_MPSOC_COMMUNICATION, serialCfg);
+                       serial::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE, UartModes::NON_CANONICAL);
-  auto specialComHelper =
+  mpsocCookie->setNoFixedSizeReply();
-      new PlocMpsocSpecialComHelper(objects::PLOC_MPSOC_HELPER, *mpsocCommunication);
+  auto plocMpsocHelper = new PlocMpsocSpecialComHelper(objects::PLOC_MPSOC_HELPER);
-  DhbConfig dhbConf(objects::PLOC_MPSOC_HANDLER);
+  auto* mpsocHandler = new PlocMpsocHandler(
-  auto* mpsocHandler = new FreshMpsocHandler(
+      objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie, plocMpsocHelper,
-      dhbConf, *mpsocCommunication, *specialComHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF),
+      Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF), objects::PLOC_SUPERVISOR_HANDLER);
      objects::PLOC_SUPERVISOR_HANDLER, pwrSwitcher, power::PDU2_CH8_PAYLOAD_CAMERA);
  mpsocHandler->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 #endif /* OBSW_ADD_PLOC_MPSOC == 1 */
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
@ -648,19 +642,15 @@ void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwit
  auto supvGpioCookie = new GpioCookie;
  supvGpioCookie->addGpio(gpioIds::ENABLE_SUPV_UART, gpioConfigSupv);
  gpioComIF->addGpios(supvGpioCookie);
-  const char* plocSupvDev = q7s::UART_PLOC_SUPERVISOR_DEV;
+  auto supervisorCookie = new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER,
-  if (not std::filesystem::exists(plocSupvDev)) {
+                                           q7s::UART_PLOC_SUPERVSIOR_DEV, serial::PLOC_SUPV_BAUD,
-    plocSupvDev = q7s::UART_PLOC_SUPERVISOR_DEV_FALLBACK;
+                                           supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
  }
  auto supervisorCookie =
      new SerialCookie(objects::PLOC_SUPERVISOR_HANDLER, plocSupvDev, serial::PLOC_SUPV_BAUD,
                       supv::MAX_PACKET_SIZE * 20, UartModes::NON_CANONICAL);
  supervisorCookie->setNoFixedSizeReply();
-  new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
+  auto supvHelper = new PlocSupvUartManager(objects::PLOC_SUPERVISOR_HELPER);
-  dhbConf = DhbConfig(objects::PLOC_SUPERVISOR_HANDLER);
+  auto* supvHandler = new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, supervisorCookie,
-  auto* supvHandler =
+                                                Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),
-      new FreshSupvHandler(dhbConf, supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF),
+                                                power::PDU1_CH6_PLOC_12V, *supvHelper);
-                           pwrSwitcher, power::PDU1_CH6_PLOC_12V);
+  supvHandler->setPowerSwitcher(&pwrSwitch);
  supvHandler->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 #endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
  static_cast<void>(consumer);
@ -760,18 +750,14 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
  gpioChecker(args.gpioComIF.addGpios(gpioCookiePtmeIp), "PTME PAPB VCs");
  // Creating virtual channel interfaces
-  VirtualChannelIF* vc0 =
+  VirtualChannelIF* vc0 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_EMPTY,
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_EMPTY, q7s::UIO_PTME,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC0);
-                          q7s::uiomapids::PTME_VC0, config::MAX_SPACEPACKET_TC_SIZE);
+  VirtualChannelIF* vc1 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_EMPTY,
-  VirtualChannelIF* vc1 =
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC1);
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_EMPTY, q7s::UIO_PTME,
+  VirtualChannelIF* vc2 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_EMPTY,
-                          q7s::uiomapids::PTME_VC1, config::MAX_SPACEPACKET_TC_SIZE);
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC2);
-  VirtualChannelIF* vc2 =
+  VirtualChannelIF* vc3 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_EMPTY,
-      new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_EMPTY, q7s::UIO_PTME,
+                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC3);
                          q7s::uiomapids::PTME_VC2, config::MAX_SPACEPACKET_TC_SIZE);
  VirtualChannelIF* vc3 =
      new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_EMPTY, q7s::UIO_PTME,
                          q7s::uiomapids::PTME_VC3, config::MAX_SPACEPACKET_TC_SIZE);
  // Creating ptme object and adding virtual channel interfaces
  Ptme* ptme = new Ptme(objects::PTME);
  ptme->addVcInterface(ccsds::VC0, vc0);
@ -791,13 +777,12 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
      new CcsdsIpCoreHandler(objects::CCSDS_HANDLER, objects::CCSDS_PACKET_DISTRIBUTOR, *ptmeConfig,
                             LINK_STATE, &args.gpioComIF, gpios, PTME_LOCKED);
  // This VC will receive all live TM
-  auto* vcWithQueue = new VirtualChannel(objects::PTME_VC0_LIVE_TM, ccsds::VC0, "PTME VC0 LIVE TM",
+  auto* vcWithQueue =
-                                         *ptme, LINK_STATE);
+      new VirtualChannelWithQueue(objects::PTME_VC0_LIVE_TM, ccsds::VC0, "PTME VC0 LIVE TM", *ptme,
                                  LINK_STATE, args.tmStore, 500);
  args.liveDestination = vcWithQueue;
  auto* liveTask = new LiveTmTask(objects::LIVE_TM_TASK, args.pusFunnel, args.cfdpFunnel,
-                                  *vcWithQueue, PTME_LOCKED, config::LIVE_CHANNEL_NORMAL_QUEUE_SIZE,
+                                  *vcWithQueue, PTME_LOCKED);
                                  config::LIVE_CHANNEL_CFDP_QUEUE_SIZE);
  args.normalLiveTmDest = liveTask->getNormalLiveQueueId();
  args.cfdpLiveTmDest = liveTask->getCfdpLiveQueueId();
  liveTask->connectModeTreeParent(satsystem::com::SUBSYSTEM);
  // Set up log store.
@ -846,7 +831,7 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
  uioNames.registers = q7s::UIO_PDEC_REGISTERS;
  uioNames.irq = q7s::UIO_PDEC_IRQ;
  new PdecHandler(objects::PDEC_HANDLER, objects::CCSDS_HANDLER, &args.gpioComIF,
-                  gpioIds::PDEC_RESET, uioNames, args.pdecCfgMemBaseAddr, args.pdecRamBaseAddr);
+                  gpioIds::PDEC_RESET, uioNames);
  GpioCookie* gpioRS485Chip = new GpioCookie;
  gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_TX_CLOCK, "RS485 Transceiver",
                                    Direction::OUT, Levels::LOW);
@ -941,7 +926,7 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
 #endif
 }
-void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher, SdCardManager& sdcMan) {
+void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
  auto* strAssy = new StrAssembly(objects::STR_ASSY);
  strAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
  auto* starTrackerCookie =
@ -955,10 +940,9 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher, SdCardManage
    sif::error << "No valid Star Tracker parameter JSON file" << std::endl;
  }
  auto strFdir = new StrFdir(objects::STAR_TRACKER);
  auto cfgGetter = new StrConfigPathGetter(sdcMan);
  auto starTracker =
      new StarTrackerHandler(objects::STAR_TRACKER, objects::STR_COM_IF, starTrackerCookie,
-                             strComIF, power::PDU1_CH2_STAR_TRACKER_5V, *cfgGetter, sdcMan);
+                             paramJsonFile, strComIF, power::PDU1_CH2_STAR_TRACKER_5V);
  starTracker->setPowerSwitcher(pwrSwitcher);
  starTracker->connectModeTreeParent(*strAssy);
  starTracker->setCustomFdir(strFdir);
@ -969,7 +953,7 @@ void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enable
  auto* imtqAssy = new ImtqAssembly(objects::IMTQ_ASSY);
  imtqAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
-  new ImtqPollingTask(objects::IMTQ_POLLING, signals::I2C_FATAL_ERRORS);
+  new ImtqPollingTask(objects::IMTQ_POLLING, I2C_FATAL_ERRORS);
  I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, imtq::MAX_REPLY_SIZE, i2cDev);
  auto imtqHandler = new ImtqHandler(objects::IMTQ_HANDLER, objects::IMTQ_POLLING, imtqI2cCookie,
                                     power::Switches::PDU1_CH3_MGT_5V, enableHkSets);
@ -1072,23 +1056,3 @@ ReturnValue_t ObjectFactory::readFirmwareVersion() {
  }
  return returnvalue::OK;
 }
 ReturnValue_t ObjectFactory::createCcsdsIpComponentsWrapper(CcsdsComponentArgs& ccsdsArgs) {
  ccsdsArgs.pdecCfgMemBaseAddr = config::pdec::PDEC_CONFIG_BASE_ADDR;
  ccsdsArgs.pdecRamBaseAddr = config::pdec::PDEC_RAM_ADDR;
  if (core::FW_VERSION_MAJOR < 6) {
    ccsdsArgs.pdecCfgMemBaseAddr = config::pdec::PDEC_CONFIG_BASE_ADDR_LEGACY;
    ccsdsArgs.pdecRamBaseAddr = config::pdec::PDEC_RAM_ADDR_LEGACY;
  }
  ReturnValue_t result = createCcsdsComponents(ccsdsArgs);
 #if OBSW_TM_TO_PTME == 1
  if (ccsdsArgs.normalLiveTmDest != MessageQueueIF::NO_QUEUE) {
    ccsdsArgs.pusFunnel.addLiveDestinationByRawId("VC0 NORMAL LIVE TM", ccsdsArgs.normalLiveTmDest,
                                                  0);
  }
  if (ccsdsArgs.cfdpLiveTmDest != MessageQueueIF::NO_QUEUE) {
    ccsdsArgs.cfdpFunnel.addLiveDestinationByRawId("VC0 CFDP LIVE TM", ccsdsArgs.cfdpLiveTmDest, 0);
  }
 #endif
  return result;
 }
--- a/bsp_q7s/objectFactory.h
+++ b/bsp_q7s/objectFactory.h
@ -15,8 +15,6 @@
 #include <atomic>
 #include <string>
 #include "bsp_q7s/fs/SdCardManager.h"
 class LinuxLibgpioIF;
 class SerialComIF;
 class SpiComIF;
@ -33,17 +31,14 @@ namespace ObjectFactory {
 struct CcsdsComponentArgs {
  CcsdsComponentArgs(LinuxLibgpioIF& gpioIF, StorageManagerIF& ipcStore, StorageManagerIF& tmStore,
                     PersistentTmStores& stores, PusTmFunnel& pusFunnel, CfdpTmFunnel& cfdpFunnel,
-                     CcsdsIpCoreHandler** ipCoreHandler, uint32_t pdecCfgMemBaseAddr,
+                     CcsdsIpCoreHandler** ipCoreHandler)
                     uint32_t pdecRamBaseAddr)
      : gpioComIF(gpioIF),
        ipcStore(ipcStore),
        tmStore(tmStore),
        stores(stores),
        pusFunnel(pusFunnel),
        cfdpFunnel(cfdpFunnel),
-        ipCoreHandler(ipCoreHandler),
+        ipCoreHandler(ipCoreHandler) {}
        pdecCfgMemBaseAddr(pdecCfgMemBaseAddr),
        pdecRamBaseAddr(pdecRamBaseAddr) {}
  LinuxLibgpioIF& gpioComIF;
  StorageManagerIF& ipcStore;
  StorageManagerIF& tmStore;
@ -51,10 +46,7 @@ struct CcsdsComponentArgs {
  PusTmFunnel& pusFunnel;
  CfdpTmFunnel& cfdpFunnel;
  CcsdsIpCoreHandler** ipCoreHandler;
-  uint32_t pdecCfgMemBaseAddr;
+  AcceptsTelemetryIF* liveDestination = nullptr;
  uint32_t pdecRamBaseAddr;
  MessageQueueId_t normalLiveTmDest = MessageQueueIF::NO_QUEUE;
  MessageQueueId_t cfdpLiveTmDest = MessageQueueIF::NO_QUEUE;
 };
 void setStatics();
@ -77,12 +69,11 @@ void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTa
                            HeaterHandler*& heaterHandler);
 void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets, const char* i2cDev);
 void createBpxBatteryComponent(bool enableHkSets, const char* i2cDev);
-void createStrComponents(PowerSwitchIF* pwrSwitcher, SdCardManager& sdcMan);
+void createStrComponents(PowerSwitchIF* pwrSwitcher);
 void createSolarArrayDeploymentComponents(PowerSwitchIF& pwrSwitcher, GpioIF& gpioIF);
 void createSyrlinksComponents(PowerSwitchIF* pwrSwitcher);
 void createPayloadComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF& pwrSwitcher);
 void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher);
 ReturnValue_t createCcsdsIpComponentsWrapper(CcsdsComponentArgs& args);
 ReturnValue_t createCcsdsComponents(CcsdsComponentArgs& args);
 ReturnValue_t readFirmwareVersion();
 void createMiscComponents();
--- a/bsp_q7s/scheduling.cpp
+++ b/bsp_q7s/scheduling.cpp
@ -82,16 +82,6 @@ void scheduling::initTasks() {
  }
 #endif
  // Medium priority, higher than something like payload, but not the highest priority to also
  // detect tasks which choke other tasks.
  PeriodicTaskIF* xiphosWdtTask =
      factory->createPeriodicTask("XIPHOS_WDT", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4,
                                  missedDeadlineFunc, &RR_SCHEDULING);
  result = xiphosWdtTask->addComponent(objects::XIPHOS_WDT);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("XIPHOS_WDT", objects::XIPHOS_WDT);
  }
  PeriodicTaskIF* coreCtrlTask = factory->createPeriodicTask(
      "CORE_CTRL", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc, &RR_SCHEDULING);
  result = coreCtrlTask->addComponent(objects::CORE_CONTROLLER);
@ -167,10 +157,6 @@ void scheduling::initTasks() {
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("PL_SUBSYSTEM", objects::PL_SUBSYSTEM);
  }
  result = genericSysTask->addComponent(objects::EPS_SUBSYSTEM);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("EPS_SUBSYSTEM", objects::EPS_SUBSYSTEM);
  }
  result = genericSysTask->addComponent(objects::INTERNAL_ERROR_REPORTER);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
@ -383,9 +369,11 @@ void scheduling::initTasks() {
  }
 #endif /* OBSW_ADD_PLOC_SUPERVISOR */
-  FixedTimeslotTaskIF* plTask = factory->createFixedTimeslotTask(
+  PeriodicTaskIF* plTask = factory->createPeriodicTask(
-      "PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc);
+      "PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc, &RR_SCHEDULING);
-  pst::pstPayload(plTask);
+  plTask->addComponent(objects::CAM_SWITCHER);
  scheduling::addMpsocSupvHandlers(plTask);
  scheduling::scheduleScexDev(plTask);
 #if OBSW_ADD_SCEX_DEVICE == 1
  PeriodicTaskIF* scexReaderTask;
@ -422,7 +410,6 @@ void scheduling::initTasks() {
  };
  sif::info << "Starting tasks.." << std::endl;
  xiphosWdtTask->startTask();
  tmTcDistributor->startTask();
 #if OBSW_ADD_TCPIP_SERVERS == 1
--- a/cmake/scripts/q7s/q7s-make-debug.sh
+++ b/cmake/scripts/q7s/q7s-make-debug.sh
@ -24,8 +24,6 @@ if [ ! -z "${EIVE_Q7S_EM}" ]; then
    build_defs="EIVE_Q7S_EM=ON"
 fi
 build_defs="${build_defs} CMAKE_EXPORT_COMPILE_COMMANDS=ON" 
 os_fsfw="linux"
 tgt_bsp="arm/q7s"
 build_dir="cmake-build-debug-q7s"
--- a/cmake/scripts/q7s/q7s-make-release.sh
+++ b/cmake/scripts/q7s/q7s-make-release.sh
@ -24,8 +24,6 @@ if [ ! -z "${EIVE_Q7S_EM}" ]; then
    build_defs="EIVE_Q7S_EM=ON"
 fi
 build_defs="${build_defs} CMAKE_EXPORT_COMPILE_COMMANDS=ON" 
 os_fsfw="linux"
 tgt_bsp="arm/q7s"
 build_dir="cmake-build-release-q7s"
--- a/common/config/devices/addresses.h
+++ b/common/config/devices/addresses.h
@ -54,9 +54,6 @@ enum I2cAddress : address_t {
 };
 enum spiAddresses : address_t {
  RTD_IC_0,
  RTD_IC_1,
  RTD_IC_2,
  RTD_IC_3,
  RTD_IC_4,
  RTD_IC_5,
@ -70,6 +67,9 @@ enum spiAddresses : address_t {
  RTD_IC_13,
  RTD_IC_14,
  RTD_IC_15,
  RTD_IC_16,
  RTD_IC_17,
  RTD_IC_18,
  RW1,
  RW2,
  RW3,
--- a/common/config/devices/gpioIds.h
+++ b/common/config/devices/gpioIds.h
@ -37,9 +37,6 @@ enum gpioId_t {
  TEST_ID_0,
  TEST_ID_1,
  RTD_IC_0,
  RTD_IC_1,
  RTD_IC_2,
  RTD_IC_3,
  RTD_IC_4,
  RTD_IC_5,
@ -53,6 +50,9 @@ enum gpioId_t {
  RTD_IC_13,
  RTD_IC_14,
  RTD_IC_15,
  RTD_IC_16,
  RTD_IC_17,
  RTD_IC_18,
  CS_SUS_0,
  CS_SUS_1,
--- a/common/config/eive/definitions.h
+++ b/common/config/eive/definitions.h
@ -20,9 +20,6 @@ static constexpr char OBSW_VERSION_FILE_PATH[] = "/usr/share/eive-obsw/obsw_vers
 // ISO8601 timestamp.
 static constexpr char FILE_DATE_FORMAT[] = "%FT%H%M%SZ";
 // Leap Seconds as of 2024-03-04
 static constexpr uint16_t LEAP_SECONDS = 37;
 static constexpr uint16_t EIVE_PUS_APID = 0x65;
 static constexpr uint16_t EIVE_CFDP_APID = 0x66;
 static constexpr uint16_t EIVE_LOCAL_CFDP_ENTITY_ID = EIVE_CFDP_APID;
@ -38,8 +35,6 @@ static constexpr uint32_t STR_IMG_HELPER_QUEUE_SIZE = 50;
 static constexpr uint8_t LIVE_TM = 0;
 static constexpr size_t MAX_SPACEPACKET_TC_SIZE = 2048;
 /* Limits for filename and path checks */
 static constexpr uint32_t MAX_PATH_SIZE = 200;
 static constexpr uint32_t MAX_FILENAME_SIZE = 100;
@ -53,8 +48,6 @@ static constexpr uint32_t LEGACY_SA_DEPL_CHANNEL_ALTERNATION_INTERVAL_SECS = 5;
 // Maximum allowed burn time allowed by the software.
 static constexpr uint32_t SA_DEPL_MAX_BURN_TIME = 180;
 static constexpr size_t CFDP_MAX_FILE_SEGMENT_LEN = 900;
 static constexpr uint32_t CCSDS_HANDLER_QUEUE_SIZE = 50;
 static constexpr uint8_t NUMBER_OF_VIRTUAL_CHANNELS = 4;
 static constexpr uint32_t VC0_LIVE_TM_QUEUE_SIZE = 300;
@ -65,25 +58,14 @@ static constexpr uint32_t NOK_STORE_QUEUE_SIZE = 350;
 static constexpr uint32_t HK_STORE_QUEUE_SIZE = 300;
 static constexpr uint32_t CFDP_STORE_QUEUE_SIZE = 300;
 static constexpr uint32_t LIVE_CHANNEL_NORMAL_QUEUE_SIZE = 250;
 static constexpr uint32_t LIVE_CHANNEL_CFDP_QUEUE_SIZE = 350;
 static constexpr uint32_t CFDP_MAX_FSM_CALL_COUNT_SRC_HANDLER = 10;
 static constexpr uint32_t CFDP_MAX_FSM_CALL_COUNT_DEST_HANDLER = 300;
 static constexpr uint32_t CFDP_SHORT_DELAY_MS = 40;
 static constexpr uint32_t CFDP_REGULAR_DELAY_MS = 200;
 static constexpr uint32_t MAX_PUS_FUNNEL_QUEUE_DEPTH = 100;
-static constexpr uint32_t MAX_CFDP_FUNNEL_QUEUE_DEPTH = LIVE_CHANNEL_CFDP_QUEUE_SIZE;
+static constexpr uint32_t MAX_CFDP_FUNNEL_QUEUE_DEPTH = 80;
 static constexpr uint32_t VERIFICATION_SERVICE_QUEUE_DEPTH = 120;
 static constexpr uint32_t HK_SERVICE_QUEUE_DEPTH = 60;
 static constexpr uint32_t ACTION_SERVICE_QUEUE_DEPTH = 60;
-static constexpr uint32_t UDP_MAX_STORED_CMDS = 200;
+static constexpr uint32_t MAX_STORED_CMDS_UDP = 150;
-static constexpr uint32_t UDP_MSG_QUEUE_DEPTH = UDP_MAX_STORED_CMDS;
+static constexpr uint32_t MAX_STORED_CMDS_TCP = 180;
 static constexpr uint32_t TCP_MAX_STORED_CMDS = 350;
 static constexpr uint32_t TCP_MSG_QUEUE_DEPTH = TCP_MAX_STORED_CMDS;
 static constexpr uint32_t TCP_MAX_NUMBER_TMS_SENT_PER_CYCLE = TCP_MSG_QUEUE_DEPTH;
 namespace spiSched {
@ -97,7 +79,6 @@ static constexpr uint32_t SCHED_BLOCK_RTD = 150;
 static constexpr uint32_t SCHED_BLOCK_7_RW_READ_MS = 300;
 static constexpr uint32_t SCHED_BLOCK_8_PLPCDU_MS = 320;
 static constexpr uint32_t SCHED_BLOCK_9_RAD_SENS_MS = 340;
 static constexpr uint32_t SCHED_BLOCK_10_PWR_CTRL_MS = 350;
 // 15 ms for FM
 static constexpr float SCHED_BLOCK_1_PERIOD = static_cast<float>(SCHED_BLOCK_1_SUS_READ_MS) / 400.0;
@ -113,23 +94,9 @@ static constexpr float SCHED_BLOCK_RTD_PERIOD = static_cast<float>(SCHED_BLOCK_R
 static constexpr float SCHED_BLOCK_7_PERIOD = static_cast<float>(SCHED_BLOCK_7_RW_READ_MS) / 400.0;
 static constexpr float SCHED_BLOCK_8_PERIOD = static_cast<float>(SCHED_BLOCK_8_PLPCDU_MS) / 400.0;
 static constexpr float SCHED_BLOCK_9_PERIOD = static_cast<float>(SCHED_BLOCK_9_RAD_SENS_MS) / 400.0;
 static constexpr float SCHED_BLOCK_10_PERIOD =
    static_cast<float>(SCHED_BLOCK_10_PWR_CTRL_MS) / 400.0;
 }  // namespace spiSched
 namespace pdec {
 // Pre FW v6.0.0
 static constexpr uint32_t PDEC_CONFIG_BASE_ADDR_LEGACY = 0x24000000;
 static constexpr uint32_t PDEC_RAM_ADDR_LEGACY = 0x26000000;
 // Post FW v6.0.0
 static constexpr uint32_t PDEC_CONFIG_BASE_ADDR = 0x4000000;
 static constexpr uint32_t PDEC_RAM_ADDR = 0x7000000;
 }  // namespace pdec
 }  // namespace config
 #endif /* COMMON_CONFIG_DEFINITIONS_H_ */
--- a/common/config/eive/eventSubsystemIds.h
+++ b/common/config/eive/eventSubsystemIds.h
@ -40,8 +40,6 @@ enum : uint8_t {
  COM_SUBSYSTEM = 142,
  PERSISTENT_TM_STORE = 143,
  SYRLINKS_COM = 144,
  SUS_HANDLER = 145,
  CFDP_APP = 146,
  COMMON_SUBSYSTEM_ID_END
 };
--- a/common/config/eive/objects.h
+++ b/common/config/eive/objects.h
@ -26,9 +26,7 @@ enum commonObjects : uint32_t {
  THERMAL_CONTROLLER = 0x43400001,
  ACS_CONTROLLER = 0x43000002,
  CORE_CONTROLLER = 0x43000003,
  POWER_CONTROLLER = 0x43000004,
  GLOBAL_JSON_CFG = 0x43000006,
  XIPHOS_WDT = 0x43000007,
  /* 0x44 ('D') for device handlers */
  MGM_0_LIS3_HANDLER = 0x44120006,
@ -77,7 +75,6 @@ enum commonObjects : uint32_t {
  PLOC_MPSOC_HANDLER = 0x44330015,
  PLOC_SUPERVISOR_HANDLER = 0x44330016,
  PLOC_SUPERVISOR_HELPER = 0x44330017,
  PLOC_MPSOC_COMMUNICATION = 0x44330018,
  SCEX = 0x44330032,
  SOLAR_ARRAY_DEPL_HANDLER = 0x444100A2,
  HEATER_HANDLER = 0x444100A4,
@ -160,14 +157,12 @@ enum commonObjects : uint32_t {
  PL_SUBSYSTEM = 0x73010002,
  TCS_SUBSYSTEM = 0x73010003,
  COM_SUBSYSTEM = 0x73010004,
  EPS_SUBSYSTEM = 0x73010005,
  TM_FUNNEL = 0x73000100,
  PUS_TM_FUNNEL = 0x73000101,
  CFDP_TM_FUNNEL = 0x73000102,
  CFDP_HANDLER = 0x73000205,
  CFDP_DISTRIBUTOR = 0x73000206,
  CFDP_FAULT_HANDLER = 0x73000207,
  MISC_TM_STORE = 0x73020001,
  OK_TM_STORE = 0x73020002,
  NOT_OK_TM_STORE = 0x73020003,
--- a/common/config/eive/resultClassIds.h
+++ b/common/config/eive/resultClassIds.h
@ -41,8 +41,6 @@ enum commonClassIds : uint8_t {
  LOCAL_PARAM_HANDLER,      // LPH
  PERSISTENT_TM_STORE,      // PTM
  TM_SINK,                  // TMS
  VIRTUAL_CHANNEL,          // VCS
  PLOC_MPSOC_COM,           // PLMPCOM
  COMMON_CLASS_ID_END       // [EXPORT] : [END]
 };
 }
--- a/dummies/GpsCtrlDummy.h
+++ b/dummies/GpsCtrlDummy.h
@ -2,7 +2,7 @@
 #define DUMMIES_GPSCTRLDUMMY_H_
 #include <fsfw/controller/ExtendedControllerBase.h>
-#include <linux/acs/GPSDefinitions.h>
+#include <mission/acs/archive/GPSDefinitions.h>
 class GpsCtrlDummy : public ExtendedControllerBase {
 public:
--- a/dummies/GpsDhbDummy.cpp
+++ b/dummies/GpsDhbDummy.cpp
@ -1,5 +1,5 @@
 #include <dummies/GpsDhbDummy.h>
-#include <linux/acs/GPSDefinitions.h>
+#include <mission/acs/archive/GPSDefinitions.h>
 GpsDhbDummy::GpsDhbDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
    : DeviceHandlerBase(objectId, comif, comCookie) {}
--- a/dummies/PlPcduDummy.cpp
+++ b/dummies/PlPcduDummy.cpp
@ -43,16 +43,3 @@ ReturnValue_t PlPcduDummy::initializeLocalDataPool(localpool::DataPool &localDat
  localDataPoolMap.emplace(plpcdu::PlPcduPoolIds::TEMP, new PoolEntry<float>({0.0}, true));
  return returnvalue::OK;
 }
 ReturnValue_t PlPcduDummy::checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
                                            uint32_t *msToReachTheMode) {
  if (commandedMode != MODE_OFF) {
    PoolReadGuard pg(&enablePl);
    if (pg.getReadResult() == returnvalue::OK) {
      if (enablePl.plUseAllowed.isValid() and not enablePl.plUseAllowed.value) {
        return NON_OP_STATE_OF_CHARGE;
      }
    }
  }
  return DeviceHandlerBase::checkModeCommand(commandedMode, commandedSubmode, msToReachTheMode);
 }
--- a/dummies/PlPcduDummy.h
+++ b/dummies/PlPcduDummy.h
@ -1,9 +1,7 @@
 #ifndef DUMMIES_PLPCDUDUMMY_H_
 #define DUMMIES_PLPCDUDUMMY_H_
 #include <common/config/eive/objects.h>
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
 #include <mission/payload/payloadPcduDefinitions.h>
 class PlPcduDummy : public DeviceHandlerBase {
@ -31,10 +29,6 @@ class PlPcduDummy : public DeviceHandlerBase {
  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                        LocalDataPoolManager &poolManager) override;
  ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
                                 uint32_t *msToReachTheMode) override;
  pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
 };
 #endif /* DUMMIES_PLPCDUDUMMY_H_ */
--- a/dummies/PlocMpsocDummy.cpp
+++ b/dummies/PlocMpsocDummy.cpp
@ -23,19 +23,6 @@ ReturnValue_t PlocMpsocDummy::buildCommandFromCommand(DeviceCommandId_t deviceCo
  return returnvalue::OK;
 }
 ReturnValue_t PlocMpsocDummy::checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
                                               uint32_t *msToReachTheMode) {
  if (commandedMode != MODE_OFF) {
    PoolReadGuard pg(&enablePl);
    if (pg.getReadResult() == returnvalue::OK) {
      if (enablePl.plUseAllowed.isValid() and not enablePl.plUseAllowed.value) {
        return NON_OP_STATE_OF_CHARGE;
      }
    }
  }
  return DeviceHandlerBase::checkModeCommand(commandedMode, commandedSubmode, msToReachTheMode);
 }
 ReturnValue_t PlocMpsocDummy::scanForReply(const uint8_t *start, size_t len,
                                           DeviceCommandId_t *foundId, size_t *foundLen) {
  return returnvalue::OK;
--- a/dummies/PlocMpsocDummy.h
+++ b/dummies/PlocMpsocDummy.h
@ -1,8 +1,6 @@
 #pragma once
 #include <common/config/eive/objects.h>
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
 #include "mission/power/defs.h"
@ -26,9 +24,6 @@ class PlocMpsocDummy : public DeviceHandlerBase {
                                        size_t commandDataLen) override;
  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
                             size_t *foundLen) override;
  ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
                                 uint32_t *msToReachTheMode) override;
  pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
  void fillCommandAndReplyMap() override;
  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
--- a/dummies/PlocSupervisorDummy.cpp
+++ b/dummies/PlocSupervisorDummy.cpp
@ -51,17 +51,3 @@ ReturnValue_t PlocSupervisorDummy::getSwitches(const uint8_t **switches,
  *switches = reinterpret_cast<const uint8_t *>(&switchId);
  return returnvalue::OK;
 }
 ReturnValue_t PlocSupervisorDummy::checkModeCommand(Mode_t commandedMode,
                                                    Submode_t commandedSubmode,
                                                    uint32_t *msToReachTheMode) {
  if (commandedMode != MODE_OFF) {
    PoolReadGuard pg(&enablePl);
    if (pg.getReadResult() == returnvalue::OK) {
      if (enablePl.plUseAllowed.isValid() and not enablePl.plUseAllowed.value) {
        return NON_OP_STATE_OF_CHARGE;
      }
    }
  }
  return DeviceHandlerBase::checkModeCommand(commandedMode, commandedSubmode, msToReachTheMode);
 }
--- a/dummies/PlocSupervisorDummy.h
+++ b/dummies/PlocSupervisorDummy.h
@ -1,8 +1,6 @@
 #pragma once
 #include <common/config/eive/objects.h>
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
 #include <mission/power/defs.h>
 class PlocSupervisorDummy : public DeviceHandlerBase {
@ -34,7 +32,4 @@ class PlocSupervisorDummy : public DeviceHandlerBase {
  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                        LocalDataPoolManager &poolManager) override;
  ReturnValue_t getSwitches(const uint8_t **switches, uint8_t *numberOfSwitches) override;
  ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
                                 uint32_t *msToReachTheMode) override;
  pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
 };
--- a/dummies/RwDummy.cpp
+++ b/dummies/RwDummy.cpp
@ -93,21 +93,3 @@ ReturnValue_t RwDummy::initializeLocalDataPool(localpool::DataPool &localDataPoo
      subdp::RegularHkPeriodicParams(lastResetStatusSet.getSid(), false, 30.0));
  return returnvalue::OK;
 }
 LocalPoolDataSetBase *RwDummy::getDataSetHandle(sid_t sid) {
  switch (sid.ownerSetId) {
    case (rws::SetIds::STATUS_SET_ID): {
      return &statusSet;
    }
    case (rws::SetIds::LAST_RESET_ID): {
      return &lastResetStatusSet;
    }
    case (rws::SetIds::SPEED_CMD_SET): {
      return &rwSpeedActuationSet;
    }
    case (rws::SetIds::TM_SET_ID): {
      return &tmDataset;
    }
  }
  return nullptr;
 }
--- a/dummies/RwDummy.h
+++ b/dummies/RwDummy.h
@ -37,7 +37,6 @@ class RwDummy : public DeviceHandlerBase {
  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                        LocalDataPoolManager &poolManager) override;
  LocalPoolDataSetBase *getDataSetHandle(sid_t sid) override;
 };
 #endif /* DUMMIES_RWDUMMY_H_ */
--- a/dummies/helperFactory.cpp
+++ b/dummies/helperFactory.cpp
@ -40,8 +40,8 @@
 #include "mission/genericFactory.h"
 #include "mission/system/acs/acsModeTree.h"
 #include "mission/system/com/comModeTree.h"
 #include "mission/system/payload/payloadModeTree.h"
 #include "mission/system/tcs/tcsModeTree.h"
 #include "mission/system/tree/payloadModeTree.h"
 #include "mission/tcs/defs.h"
 void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpioIF,
@ -95,7 +95,7 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
  }
  if (cfg.addAcsBoardDummies) {
-    std::array<DeviceHandlerBase*, 8> assemblyDhbs{};
+    std::array<DeviceHandlerBase*, 8> assemblyDhbs;
    assemblyDhbs[0] =
        new MgmLIS3MDLDummy(objects::MGM_0_LIS3_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
    assemblyDhbs[1] =
@ -117,7 +117,7 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
  }
  if (cfg.addSusDummies) {
-    std::array<DeviceHandlerBase*, 12> suses{};
+    std::array<DeviceHandlerBase*, 12> suses;
    suses[0] =
        new SusDummy(objects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::DUMMY_COM_IF, comCookieDummy);
    suses[1] =
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit 42867ad0cba088ab1cb6cb672d001f991f7e4a60
+Subproject commit d246ce34d05ecc5c722fd127e61556374961c899
--- a/generators/bsp_hosted_events.csv
+++ b/generators/bsp_hosted_events.csv
@ -75,12 +75,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 7902;0x1ede;BIT_LOCK;INFO;A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7903;0x1edf;BIT_LOCK_LOST;INFO;A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7905;0x1ee1;FRAME_PROCESSING_FAILED;LOW;The CCSDS Board could not interpret a TC;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
-8900;0x22c4;CLOCK_SET;INFO;Clock has been set. P1: old timeval seconds. P2: new timeval seconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8900;0x22c4;CLOCK_SET;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8901;0x22c5;CLOCK_DUMP_LEGACY;INFO;Clock dump event. P1: timeval seconds P2: timeval milliseconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8901;0x22c5;CLOCK_DUMP;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8902;0x22c6;CLOCK_SET_FAILURE;LOW;Clock could not be set. P1: Returncode.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8902;0x22c6;CLOCK_SET_FAILURE;LOW;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
 8903;0x22c7;CLOCK_DUMP;INFO;Clock dump event. P1: timeval seconds P2: timeval microseconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
 8904;0x22c8;CLOCK_DUMP_BEFORE_SETTING_TIME;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
 8905;0x22c9;CLOCK_DUMP_AFTER_SETTING_TIME;INFO;No description;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;No description;fsfw/src/fsfw/pus/Service17Test.h
 10600;0x2968;CHANGE_OF_SETUP_PARAMETER;LOW;No description;fsfw/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
@ -89,28 +86,19 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 10802;0x2a32;SERIALIZATION_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
 10803;0x2a33;FILESTORE_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
 10804;0x2a34;FILENAME_TOO_LARGE_ERROR;LOW;P1: Transaction step ID, P2: 0 for source file name, 1 for dest file name;fsfw/src/fsfw/cfdp/handler/defs.h
 10805;0x2a35;HANDLING_CFDP_REQUEST_FAILED;LOW;CFDP request handling failed. P2: Returncode.;fsfw/src/fsfw/cfdp/handler/defs.h
 11200;0x2bc0;SAFE_RATE_VIOLATION;MEDIUM;The limits for the rotation in safe mode were violated.;mission/acs/defs.h
-11201;0x2bc1;RATE_RECOVERY;MEDIUM;The system has recovered from a rate rotation violation.;mission/acs/defs.h
+11201;0x2bc1;SAFE_RATE_RECOVERY;MEDIUM;The system has recovered from a safe rate rotation violation.;mission/acs/defs.h
 11202;0x2bc2;MULTIPLE_RW_INVALID;HIGH;Multiple RWs are invalid, uncommandable and therefore higher ACS modes cannot be maintained.;mission/acs/defs.h
 11203;0x2bc3;MEKF_INVALID_INFO;INFO;MEKF was not able to compute a solution. P1: MEKF state on exit;mission/acs/defs.h
 11204;0x2bc4;MEKF_RECOVERY;INFO;MEKF is able to compute a solution again.;mission/acs/defs.h
 11205;0x2bc5;MEKF_AUTOMATIC_RESET;INFO;MEKF performed an automatic reset after detection of nonfinite values.;mission/acs/defs.h
-11206;0x2bc6;PTG_CTRL_NO_ATTITUDE_INFORMATION;HIGH;For a prolonged time, no attitude information was available for the Pointing Controller. Falling back to Safe Mode.;mission/acs/defs.h
+11206;0x2bc6;MEKF_INVALID_MODE_VIOLATION;HIGH;MEKF was not able to compute a solution during any pointing ACS mode for a prolonged time.;mission/acs/defs.h
 11207;0x2bc7;SAFE_MODE_CONTROLLER_FAILURE;HIGH;The ACS safe mode controller was not able to compute a solution and has failed. P1: Missing information about magnetic field, P2: Missing information about rotational rate;mission/acs/defs.h
 11208;0x2bc8;TLE_TOO_OLD;INFO;The TLE for the SGP4 Propagator has become too old.;mission/acs/defs.h
 11209;0x2bc9;TLE_FILE_READ_FAILED;LOW;The TLE could not be read from the filesystem.;mission/acs/defs.h
 11210;0x2bca;PTG_RATE_VIOLATION;MEDIUM;The limits for the rotation in pointing mode were violated.;mission/acs/defs.h
 11211;0x2bcb;DETUMBLE_TRANSITION_FAILED;HIGH;The detumble transition has failed. //! P1: Last detumble state before failure.;mission/acs/defs.h
 11300;0x2c24;SWITCH_CMD_SENT;INFO;Indicates that a FSFW object requested setting a switch P1: 1 if on was requested, 0 for off | P2: Switch Index;mission/power/defs.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/power/defs.h
 11302;0x2c26;SWITCHING_Q7S_DENIED;MEDIUM;No description;mission/power/defs.h
 11303;0x2c27;FDIR_REACTION_IGNORED;MEDIUM;No description;mission/power/defs.h
 11304;0x2c28;DATASET_READ_FAILED;INFO;The dataset read for the inputs of the Power Controller has failed.;mission/power/defs.h
 11305;0x2c29;VOLTAGE_OUT_OF_BOUNDS;HIGH;No description;mission/power/defs.h
 11306;0x2c2a;TIMEDELTA_OUT_OF_BOUNDS;LOW;Time difference for Coulomb Counter was too large. P1: time in s * 10;mission/power/defs.h
 11307;0x2c2b;POWER_LEVEL_LOW;HIGH;The State of Charge is below the limit for payload use. Setting Payload to faulty.;mission/power/defs.h
 11308;0x2c2c;POWER_LEVEL_CRITICAL;HIGH;The State of Charge is below the limit for higher modes. Setting Reaction Wheels to faulty.;mission/power/defs.h
 11400;0x2c88;GPIO_PULL_HIGH_FAILED;LOW;No description;mission/tcs/HeaterHandler.h
 11401;0x2c89;GPIO_PULL_LOW_FAILED;LOW;No description;mission/tcs/HeaterHandler.h
 11402;0x2c8a;HEATER_WENT_ON;INFO;No description;mission/tcs/HeaterHandler.h
@ -128,15 +116,12 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11506;0x2cf2;DEPL_SA1_GPIO_SWTICH_OFF_FAILED;HIGH;No description;mission/SolarArrayDeploymentHandler.h
 11507;0x2cf3;DEPL_SA2_GPIO_SWTICH_OFF_FAILED;HIGH;No description;mission/SolarArrayDeploymentHandler.h
 11508;0x2cf4;AUTONOMOUS_DEPLOYMENT_COMPLETED;INFO;No description;mission/SolarArrayDeploymentHandler.h
-11601;0x2d51;MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC crc failure in telemetry packet;linux/payload/plocMpsocHelpers.h
+11601;0x2d51;MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC crc failure in telemetry packet;linux/payload/PlocMpsocHandler.h
-11602;0x2d52;ACK_FAILURE;LOW;PLOC receive acknowledgment failure report P1: Command Id which leads the acknowledgment failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/plocMpsocHelpers.h
+11602;0x2d52;ACK_FAILURE;LOW;PLOC receive acknowledgment failure report P1: Command Id which leads the acknowledgment failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/PlocMpsocHandler.h
-11603;0x2d53;EXE_FAILURE;LOW;PLOC receive execution failure report P1: Command Id which leads the execution failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/plocMpsocHelpers.h
+11603;0x2d53;EXE_FAILURE;LOW;PLOC receive execution failure report P1: Command Id which leads the execution failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/PlocMpsocHandler.h
-11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/payload/plocMpsocHelpers.h
+11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/payload/PlocMpsocHandler.h
-11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/payload/plocMpsocHelpers.h
+11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/payload/PlocMpsocHandler.h
-11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/payload/plocMpsocHelpers.h
+11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/payload/PlocMpsocHandler.h
 11607;0x2d57;SUPV_NOT_ON;LOW;SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for ON transition.;linux/payload/plocMpsocHelpers.h
 11608;0x2d58;SUPV_REPLY_TIMEOUT;LOW;SUPV reply timeout.;linux/payload/plocMpsocHelpers.h
 11609;0x2d59;CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE;LOW;Camera must be commanded on first.;linux/payload/plocMpsocHelpers.h
 11701;0x2db5;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11702;0x2db6;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11703;0x2db7;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
@ -150,16 +135,14 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11901;0x2e7d;BOOTING_FIRMWARE_FAILED_EVENT;LOW;Failed to boot firmware;mission/acs/str/StarTrackerHandler.h
 11902;0x2e7e;BOOTING_BOOTLOADER_FAILED_EVENT;LOW;Failed to boot star tracker into bootloader mode;mission/acs/str/StarTrackerHandler.h
 11903;0x2e7f;COM_ERROR_REPLY_RECEIVED;LOW;Received COM error. P1:  Communication Error ID (datasheet p32);mission/acs/str/StarTrackerHandler.h
-12001;0x2ee1;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/payload/plocSupvDefs.h
+12001;0x2ee1;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/payload/PlocSupervisorHandler.h
-12002;0x2ee2;SUPV_UNKNOWN_TM;LOW;Unhandled event. P1: APID, P2: Service ID;linux/payload/plocSupvDefs.h
+12002;0x2ee2;SUPV_UNKNOWN_TM;LOW;Unhandled event. P1: APID, P2: Service ID;linux/payload/PlocSupervisorHandler.h
-12003;0x2ee3;SUPV_UNINIMPLEMENTED_TM;LOW;No description;linux/payload/plocSupvDefs.h
+12003;0x2ee3;SUPV_UNINIMPLEMENTED_TM;LOW;No description;linux/payload/PlocSupervisorHandler.h
-12004;0x2ee4;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/payload/plocSupvDefs.h
+12004;0x2ee4;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/payload/PlocSupervisorHandler.h
-12005;0x2ee5;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report P1: ID of command for which the execution failed P2: Status code sent by the supervisor handler;linux/payload/plocSupvDefs.h
+12005;0x2ee5;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report P1: ID of command for which the execution failed P2: Status code sent by the supervisor handler;linux/payload/PlocSupervisorHandler.h
-12006;0x2ee6;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/payload/plocSupvDefs.h
+12006;0x2ee6;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/payload/PlocSupervisorHandler.h
-12007;0x2ee7;SUPV_HELPER_EXECUTING;LOW;Supervisor helper currently executing a command;linux/payload/plocSupvDefs.h
+12007;0x2ee7;SUPV_HELPER_EXECUTING;LOW;Supervisor helper currently executing a command;linux/payload/PlocSupervisorHandler.h
-12008;0x2ee8;SUPV_MPSOC_SHUTDOWN_BUILD_FAILED;LOW;Failed to build the command to shutdown the MPSoC;linux/payload/plocSupvDefs.h
+12008;0x2ee8;SUPV_MPSOC_SHUTDOWN_BUILD_FAILED;LOW;Failed to build the command to shutdown the MPSoC;linux/payload/PlocSupervisorHandler.h
 12009;0x2ee9;SUPV_ACK_UNKNOWN_COMMAND;LOW;Received ACK, but no related command is unknown or has not been sent  by this software instance. P1: Module APID. P2: Service ID.;linux/payload/plocSupvDefs.h
 12010;0x2eea;SUPV_EXE_ACK_UNKNOWN_COMMAND;LOW;Received ACK EXE, but no related command is unknown or has not been sent  by this software instance. P1: Module APID. P2: Service ID.;linux/payload/plocSupvDefs.h
 12100;0x2f44;SANITIZATION_FAILED;LOW;No description;bsp_q7s/fs/SdCardManager.h
 12101;0x2f45;MOUNTED_SD_CARD;INFO;No description;bsp_q7s/fs/SdCardManager.h
 12300;0x300c;SEND_MRAM_DUMP_FAILED;LOW;Failed to send mram dump command to supervisor handler P1: Return value of commandAction function P2: Start address of MRAM to dump with this command;linux/payload/PlocMemoryDumper.h
@ -237,9 +220,8 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12902;0x3266;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;No description;mission/system/acs/SusAssembly.h
 12903;0x3267;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/acs/SusAssembly.h
 13000;0x32c8;CHILDREN_LOST_MODE;MEDIUM;No description;mission/system/tcs/TcsBoardAssembly.h
-13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: New fix. P2: Missed fix changes 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;linux/acs/GPSDefinitions.h
+13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: Old fix. P2: New fix 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;mission/acs/archive/GPSDefinitions.h
-13101;0x332d;CANT_GET_FIX;MEDIUM;Could not get fix in maximum allowed time. Trying to reset both GNSS devices. P1: Maximum allowed time to get a fix after the GPS was switched on.;linux/acs/GPSDefinitions.h
+13101;0x332d;CANT_GET_FIX;LOW;Could not get fix in maximum allowed time. P1: Maximum allowed time to get a fix after the GPS was switched on.;mission/acs/archive/GPSDefinitions.h
 13102;0x332e;RESET_FAIL;HIGH;Failed to reset an GNNS Device. P1: Board-Side.;linux/acs/GPSDefinitions.h
 13200;0x3390;P60_BOOT_COUNT;INFO;P60 boot count is broadcasted once at SW startup. P1: Boot count;mission/power/P60DockHandler.h
 13201;0x3391;BATT_MODE;INFO;Battery mode is broadcasted at startup. P1: Mode;mission/power/P60DockHandler.h
 13202;0x3392;BATT_MODE_CHANGED;MEDIUM;Battery mode has changed. P1: Old mode. P2: New mode;mission/power/P60DockHandler.h
@ -321,6 +303,3 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14312;0x37e8;DUMP_MISC_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14313;0x37e9;DUMP_HK_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14314;0x37ea;DUMP_CFDP_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14500;0x38a4;TEMPERATURE_ALL_ONES_START;MEDIUM;Detected invalid values, starting invalid message counting;mission/acs/SusHandler.h
 14501;0x38a5;TEMPERATURE_ALL_ONES_RECOVERY;INFO;Detected valid values for a prolonged time again, resetting all counters. P1: Number of periods with invalid messages. P2: Maximum invalid message counter.;mission/acs/SusHandler.h
 14600;0x3908;FAULT_HANDLER_TRIGGERED;LOW;P1: CFDP fault handler code. P2: CFDP condition code.;mission/cfdp/defs.h
--- a/generators/bsp_hosted_objects.csv
+++ b/generators/bsp_hosted_objects.csv
@ -1,9 +1,7 @@
 0x42694269;TEST_TASK
 0x43000002;ACS_CONTROLLER
 0x43000003;CORE_CONTROLLER
 0x43000004;POWER_CONTROLLER
 0x43000006;GLOBAL_JSON_CFG
 0x43000007;XIPHOS_WDT
 0x43400001;THERMAL_CONTROLLER
 0x44000001;DUMMY_HANDLER
 0x44120006;MGM_0_LIS3_HANDLER
@ -57,7 +55,6 @@
 0x44330015;PLOC_MPSOC_HANDLER
 0x44330016;PLOC_SUPERVISOR_HANDLER
 0x44330017;PLOC_SUPERVISOR_HELPER
 0x44330018;PLOC_MPSOC_COMMUNICATION
 0x44330032;SCEX
 0x444100A2;SOLAR_ARRAY_DEPL_HANDLER
 0x444100A4;HEATER_HANDLER
@ -154,13 +151,11 @@
 0x73000102;CFDP_TM_FUNNEL
 0x73000205;CFDP_HANDLER
 0x73000206;CFDP_DISTRIBUTOR
 0x73000207;CFDP_FAULT_HANDLER
 0x73010000;EIVE_SYSTEM
 0x73010001;ACS_SUBSYSTEM
 0x73010002;PL_SUBSYSTEM
 0x73010003;TCS_SUBSYSTEM
 0x73010004;COM_SUBSYSTEM
 0x73010005;EPS_SUBSYSTEM
 0x73020001;MISC_TM_STORE
 0x73020002;OK_TM_STORE
 0x73020003;NOT_OK_TM_STORE
--- a/generators/bsp_hosted_returnvalues.csv
+++ b/generators/bsp_hosted_returnvalues.csv
@ -210,7 +210,6 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x27a8;DHI_NoReplyExpected;No description;168;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27a9;DHI_NonOpTemperature;No description;169;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27aa;DHI_CommandNotImplemented;No description;170;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27ab;DHI_NonOpStateOfCharge;No description;171;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b0;DHI_ChecksumError;No description;176;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b1;DHI_LengthMissmatch;No description;177;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b2;DHI_InvalidData;No description;178;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
@ -323,211 +322,193 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x3405;DC_NotActive;No description;5;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
 0x3406;DC_TooMuchData;No description;6;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
 0x3407;DC_Busy;No description;7;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3601;CFDP_InvalidTlvType;No description;1;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3601;CFDP_InvalidTlvType;No description;1;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3602;CFDP_InvalidDirectiveField;No description;2;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3602;CFDP_InvalidDirectiveField;No description;2;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3603;CFDP_InvalidPduDatafieldLen;No description;3;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3603;CFDP_InvalidPduDatafieldLen;No description;3;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3604;CFDP_InvalidAckDirectiveFields;No description;4;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3604;CFDP_InvalidAckDirectiveFields;No description;4;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3605;CFDP_MetadataCantParseOptions;No description;5;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3605;CFDP_MetadataCantParseOptions;No description;5;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3606;CFDP_NakCantParseOptions;No description;6;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3606;CFDP_NakCantParseOptions;No description;6;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3607;CFDP_FinishedCantParseFsResponses;No description;7;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3607;CFDP_FinishedCantParseFsResponses;No description;7;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3608;CFDP_FilestoreRequiresSecondFile;No description;8;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3608;CFDP_FilestoreRequiresSecondFile;No description;8;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3609;CFDP_FilestoreResponseCantParseFsMessage;No description;9;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3609;CFDP_FilestoreResponseCantParseFsMessage;No description;9;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x360a;CFDP_InvalidPduFormat;No description;10;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x360a;CFDP_InvalidPduFormat;No description;10;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3700;CFDP_SourceTransactionPending;No description;0;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3701;TSI_BadTimestamp;No description;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
-0x3701;CFDP_FileDoesNotExist;No description;1;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38a1;SGP4_InvalidEccentricity;No description;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3702;CFDP_FileSegmentLenInvalid;No description;2;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38a2;SGP4_InvalidMeanMotion;No description;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3703;CFDP_SourceNameEmpty;No description;3;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38a3;SGP4_InvalidPerturbationElements;No description;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3704;CFDP_DestNameEmpty;No description;4;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38a4;SGP4_InvalidSemiLatusRectum;No description;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3705;CFDP_WrongRemoteCfgEntityId;No description;5;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38a5;SGP4_InvalidEpochElements;No description;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3706;CFDP_TargetMsgQueueFull;No description;6;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38a6;SGP4_SatelliteHasDecayed;No description;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3707;CFDP_TmStoreFull;No description;7;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38b1;SGP4_TleTooOld;No description;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3801;TSI_BadTimestamp;No description;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
+0x38b2;SGP4_TleNotInitialized;No description;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x39a1;SGP4_InvalidEccentricity;No description;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3901;MUX_NotEnoughResources;No description;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39a2;SGP4_InvalidMeanMotion;No description;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3902;MUX_InsufficientMemory;No description;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39a3;SGP4_InvalidPerturbationElements;No description;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3903;MUX_NoPrivilege;No description;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39a4;SGP4_InvalidSemiLatusRectum;No description;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3904;MUX_WrongAttributeSetting;No description;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39a5;SGP4_InvalidEpochElements;No description;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3905;MUX_MutexAlreadyLocked;No description;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39a6;SGP4_SatelliteHasDecayed;No description;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3906;MUX_MutexNotFound;No description;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39b1;SGP4_TleTooOld;No description;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3907;MUX_MutexMaxLocks;No description;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39b2;SGP4_TleNotInitialized;No description;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3908;MUX_CurrThreadAlreadyOwnsMutex;No description;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3a01;MUX_NotEnoughResources;No description;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3909;MUX_CurrThreadDoesNotOwnMutex;No description;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3a02;MUX_InsufficientMemory;No description;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x390a;MUX_MutexTimeout;No description;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3a03;MUX_NoPrivilege;No description;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x390b;MUX_MutexInvalidId;No description;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3a04;MUX_WrongAttributeSetting;No description;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x390c;MUX_MutexDestroyedWhileWaiting;No description;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3a05;MUX_MutexAlreadyLocked;No description;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a01;MQI_Empty;No description;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a06;MUX_MutexNotFound;No description;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a07;MUX_MutexMaxLocks;No description;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a08;MUX_CurrThreadAlreadyOwnsMutex;No description;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a09;MUX_CurrThreadDoesNotOwnMutex;No description;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3b01;SPH_SemaphoreTimeout;No description;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3a0a;MUX_MutexTimeout;No description;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3b02;SPH_SemaphoreNotOwned;No description;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3a0b;MUX_MutexInvalidId;No description;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3b03;SPH_SemaphoreInvalid;No description;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3a0c;MUX_MutexDestroyedWhileWaiting;No description;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3c00;LPIF_PoolEntryNotFound;No description;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
-0x3b01;MQI_Empty;No description;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3c01;LPIF_PoolEntryTypeConflict;No description;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
-0x3b02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3da0;PVA_InvalidReadWriteMode;No description;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
-0x3b03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3da1;PVA_InvalidPoolEntry;No description;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
-0x3b04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3e00;HKM_QueueOrDestinationInvalid;No description;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3c01;SPH_SemaphoreTimeout;No description;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3e01;HKM_WrongHkPacketType;No description;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3c02;SPH_SemaphoreNotOwned;No description;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3e02;HKM_ReportingStatusUnchanged;No description;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3c03;SPH_SemaphoreInvalid;No description;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3e03;HKM_PeriodicHelperInvalid;No description;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d00;LPIF_PoolEntryNotFound;No description;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3e04;HKM_PoolobjectNotFound;No description;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d01;LPIF_PoolEntryTypeConflict;No description;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3e05;HKM_DatasetNotFound;No description;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3ea0;PVA_InvalidReadWriteMode;No description;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
+0x3f01;DLEE_StreamTooShort;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x3ea1;PVA_InvalidPoolEntry;No description;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
+0x3f02;DLEE_DecodingError;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x3f00;HKM_QueueOrDestinationInvalid;No description;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4100;PUS9_ConnBroken;No description;0;PUS_SERVICE_9;fsfw/src/fsfw/osal/common/TcpTmTcServer.h
-0x3f01;HKM_WrongHkPacketType;No description;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4201;PUS11_InvalidTypeTimeWindow;No description;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x3f02;HKM_ReportingStatusUnchanged;No description;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4202;PUS11_InvalidTimeWindow;No description;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x3f03;HKM_PeriodicHelperInvalid;No description;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4203;PUS11_TimeshiftingNotPossible;No description;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x3f04;HKM_PoolobjectNotFound;No description;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4204;PUS11_InvalidRelativeTime;No description;4;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x3f05;HKM_DatasetNotFound;No description;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4205;PUS11_ContainedTcTooSmall;No description;5;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4001;DLEE_StreamTooShort;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x4206;PUS11_ContainedTcCrcMissmatch;No description;6;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4002;DLEE_DecodingError;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x4300;FILS_GenericFileError;No description;0;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4301;PUS11_InvalidTypeTimeWindow;No description;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4301;FILS_GenericDirError;No description;1;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4302;PUS11_InvalidTimeWindow;No description;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4302;FILS_FilesystemInactive;No description;2;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4303;PUS11_TimeshiftingNotPossible;No description;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4303;FILS_GenericRenameError;No description;3;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4304;PUS11_InvalidRelativeTime;No description;4;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4304;FILS_IsBusy;No description;4;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4305;PUS11_ContainedTcTooSmall;No description;5;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4305;FILS_InvalidParameters;No description;5;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4306;PUS11_ContainedTcCrcMissmatch;No description;6;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x430a;FILS_FileDoesNotExist;No description;10;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4307;PUS11_MapIsFull;No description;7;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x430b;FILS_FileAlreadyExists;No description;11;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4400;FILS_GenericFileError;No description;0;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430c;FILS_NotAFile;No description;12;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4401;FILS_GenericDirError;No description;1;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430d;FILS_FileLocked;No description;13;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4402;FILS_FilesystemInactive;No description;2;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430e;FILS_PermissionDenied;No description;14;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4403;FILS_GenericRenameError;No description;3;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4315;FILS_DirectoryDoesNotExist;No description;21;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4404;FILS_IsBusy;No description;4;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4316;FILS_DirectoryAlreadyExists;No description;22;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4405;FILS_InvalidParameters;No description;5;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4317;FILS_NotADirectory;No description;23;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x440a;FILS_FileDoesNotExist;No description;10;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4318;FILS_DirectoryNotEmpty;No description;24;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x440b;FILS_FileAlreadyExists;No description;11;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x431e;FILS_SequencePacketMissingWrite;No description;30;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x440c;FILS_NotAFile;No description;12;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x431f;FILS_SequencePacketMissingRead;No description;31;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x440d;FILS_FileLocked;No description;13;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4400;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x440e;FILS_PermissionDenied;No description;14;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4401;UXOS_CommandPending;Command is pending. This will also be returned if the user tries to load another command but a command is still pending;1;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4415;FILS_DirectoryDoesNotExist;No description;21;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4402;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4416;FILS_DirectoryAlreadyExists;No description;22;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4417;FILS_NotADirectory;No description;23;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4418;FILS_DirectoryNotEmpty;No description;24;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4406;UXOS_PcloseCallError;No description;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x441e;FILS_SequencePacketMissingWrite;No description;30;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4500;HSPI_HalTimeoutRetval;No description;0;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x441f;FILS_SequencePacketMissingRead;No description;31;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4501;HSPI_HalBusyRetval;No description;1;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x4500;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4502;HSPI_HalErrorRetval;No description;2;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x4501;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
+0x4503;HSPI_Timeout;No description;3;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4502;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4504;HSPI_Busy;No description;4;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4503;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4505;HSPI_GenericError;No description;5;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4504;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4601;HURT_UartReadFailure;No description;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4506;UXOS_PcloseCallError;No description;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4602;HURT_UartReadSizeMissmatch;No description;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4600;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4603;HURT_UartRxBufferTooSmall;No description;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4601;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4801;HGIO_UnknownGpioId;No description;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4602;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4802;HGIO_DriveGpioFailure;No description;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4603;HSPI_Timeout;No description;3;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4803;HGIO_GpioTypeFailure;No description;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4604;HSPI_Busy;No description;4;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4804;HGIO_GpioInvalidInstance;No description;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4605;HSPI_GenericError;No description;5;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4805;HGIO_GpioDuplicateDetected;No description;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4701;HURT_UartReadFailure;No description;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4806;HGIO_GpioInitFailed;No description;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4702;HURT_UartReadSizeMissmatch;No description;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4807;HGIO_GpioGetValueFailed;No description;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4703;HURT_UartRxBufferTooSmall;No description;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4c00;SPPA_NoPacketFound;No description;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x4901;HGIO_UnknownGpioId;No description;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4c01;SPPA_SplitPacket;No description;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x4902;HGIO_DriveGpioFailure;No description;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4fa1;HEATER_CommandNotSupported;No description;161;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4903;HGIO_GpioTypeFailure;No description;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4fa2;HEATER_InitFailed;No description;162;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4904;HGIO_GpioInvalidInstance;No description;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4fa3;HEATER_InvalidSwitchNr;No description;163;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4905;HGIO_GpioDuplicateDetected;No description;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4fa4;HEATER_MainSwitchSetTimeout;No description;164;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4906;HGIO_GpioInitFailed;No description;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4fa5;HEATER_CommandAlreadyWaiting;No description;165;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4907;HGIO_GpioGetValueFailed;No description;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x50a0;SYRLINKS_CrcFailure;No description;160;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x4d00;SPPA_NoPacketFound;No description;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x50a1;SYRLINKS_UartFraminOrParityErrorAck;No description;161;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x4d01;SPPA_SplitPacket;No description;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x50a2;SYRLINKS_BadCharacterAck;No description;162;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a1;HEATER_CommandNotSupported;No description;161;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a3;SYRLINKS_BadParameterValueAck;No description;163;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a2;HEATER_InitFailed;No description;162;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a4;SYRLINKS_BadEndOfFrameAck;No description;164;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a3;HEATER_InvalidSwitchNr;No description;163;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a5;SYRLINKS_UnknownCommandIdAck;No description;165;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a4;HEATER_MainSwitchSetTimeout;No description;164;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a6;SYRLINKS_BadCrcAck;No description;166;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a5;HEATER_CommandAlreadyWaiting;No description;165;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a7;SYRLINKS_ReplyWrongSize;No description;167;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x51a0;SYRLINKS_CrcFailure;No description;160;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x50a8;SYRLINKS_MissingStartFrameCharacter;No description;168;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x51a1;SYRLINKS_UartFraminOrParityErrorAck;No description;161;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5100;IMTQ_InvalidCommandCode;No description;0;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a2;SYRLINKS_BadCharacterAck;No description;162;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5101;IMTQ_MgmMeasurementLowLevelError;No description;1;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a3;SYRLINKS_BadParameterValueAck;No description;163;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5102;IMTQ_ActuateCmdLowLevelError;No description;2;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a4;SYRLINKS_BadEndOfFrameAck;No description;164;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5103;IMTQ_ParameterMissing;No description;3;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a5;SYRLINKS_UnknownCommandIdAck;No description;165;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5104;IMTQ_ParameterInvalid;No description;4;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a6;SYRLINKS_BadCrcAck;No description;166;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5105;IMTQ_CcUnavailable;No description;5;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a7;SYRLINKS_ReplyWrongSize;No description;167;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5106;IMTQ_InternalProcessingError;No description;6;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a8;SYRLINKS_MissingStartFrameCharacter;No description;168;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5107;IMTQ_RejectedWithoutReason;No description;7;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5200;IMTQ_InvalidCommandCode;No description;0;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5108;IMTQ_CmdErrUnknown;No description;8;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5201;IMTQ_MgmMeasurementLowLevelError;No description;1;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5109;IMTQ_StartupCfgError;No description;9;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5202;IMTQ_ActuateCmdLowLevelError;No description;2;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x510a;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.;10;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5203;IMTQ_ParameterMissing;No description;3;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b0;RWHA_SpiWriteFailure;No description;176;RW_HANDLER;mission/acs/rwHelpers.h
-0x5204;IMTQ_ParameterInvalid;No description;4;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/acs/rwHelpers.h
-0x5205;IMTQ_CcUnavailable;No description;5;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/acs/rwHelpers.h
-0x5206;IMTQ_InternalProcessingError;No description;6;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b3;RWHA_InvalidSubstitute;Can be used by the HDLC decoding mechanism to inform about an invalid substitution combination;179;RW_HANDLER;mission/acs/rwHelpers.h
-0x5207;IMTQ_RejectedWithoutReason;No description;7;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b4;RWHA_MissingEndSign;HDLC decoding mechanism never receives the end sign 0x7E;180;RW_HANDLER;mission/acs/rwHelpers.h
-0x5208;IMTQ_CmdErrUnknown;No description;8;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/acs/rwHelpers.h
-0x5209;IMTQ_StartupCfgError;No description;9;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/acs/rwHelpers.h
-0x520a;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.;10;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b7;RWHA_SpiReadTimeout;Timeout when reading reply;183;RW_HANDLER;mission/acs/rwHelpers.h
-0x53a0;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/acs/RwHandler.h
+0x53a0;STRH_TemperatureReqFailed;Status in temperature reply signals error;160;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a1;RWHA_InvalidRampTime;Action Message with invalid ramp time was received.;161;RW_HANDLER;mission/acs/RwHandler.h
+0x53a1;STRH_PingFailed;Ping command failed;161;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a2;RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;RW_HANDLER;mission/acs/RwHandler.h
+0x53a2;STRH_VersionReqFailed;Status in version reply signals error;162;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a3;RWHA_ExecutionFailed;Command execution failed;163;RW_HANDLER;mission/acs/RwHandler.h
+0x53a3;STRH_InterfaceReqFailed;Status in interface reply signals error;163;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a4;RWHA_CrcError;Reaction wheel reply has invalid crc;164;RW_HANDLER;mission/acs/RwHandler.h
+0x53a4;STRH_PowerReqFailed;Status in power reply signals error;164;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a5;RWHA_ValueNotRead;No description;165;RW_HANDLER;mission/acs/RwHandler.h
+0x53a5;STRH_SetParamFailed;Status of reply to parameter set command signals error;165;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b0;RWHA_SpiWriteFailure;No description;176;RW_HANDLER;mission/acs/rwHelpers.h
+0x53a6;STRH_ActionFailed;Status of reply to action command signals error;166;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/acs/rwHelpers.h
+0x53a7;STRH_FilePathTooLong;Received invalid path string. Exceeds allowed length;167;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/acs/rwHelpers.h
+0x53a8;STRH_FilenameTooLong;Name of file received with command is too long;168;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b3;RWHA_InvalidSubstitute;Can be used by the HDLC decoding mechanism to inform about an invalid substitution combination;179;RW_HANDLER;mission/acs/rwHelpers.h
+0x53a9;STRH_InvalidProgram;Received version reply with invalid program ID;169;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b4;RWHA_MissingEndSign;HDLC decoding mechanism never receives the end sign 0x7E;180;RW_HANDLER;mission/acs/rwHelpers.h
+0x53aa;STRH_ReplyError;Status field reply signals error;170;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/acs/rwHelpers.h
+0x53ab;STRH_CommandTooShort;Received command which is too short (some data is missing for proper execution);171;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/acs/rwHelpers.h
+0x53ac;STRH_InvalidLength;Received command with invalid length (too few or too many parameters);172;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b7;RWHA_SpiReadTimeout;Timeout when reading reply;183;RW_HANDLER;mission/acs/rwHelpers.h
+0x53ad;STRH_RegionMismatch;Region mismatch between send and received data;173;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a0;STRH_TemperatureReqFailed;Status in temperature reply signals error;160;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53ae;STRH_AddressMismatch;Address mismatch between send and received data;174;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a1;STRH_PingFailed;Ping command failed;161;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53af;STRH_LengthMismatch;Length field mismatch between send and received data;175;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a2;STRH_VersionReqFailed;Status in version reply signals error;162;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b0;STRH_FileNotExists;Specified file does not exist;176;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a3;STRH_InterfaceReqFailed;Status in interface reply signals error;163;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b1;STRH_InvalidType;Download blob pixel command has invalid type field;177;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a4;STRH_PowerReqFailed;Status in power reply signals error;164;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b2;STRH_InvalidId;Received FPGA action command with invalid ID;178;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a5;STRH_SetParamFailed;Status of reply to parameter set command signals error;165;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b3;STRH_ReplyTooShort;Received reply is too short;179;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a6;STRH_ActionFailed;Status of reply to action command signals error;166;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b4;STRH_CrcFailure;Received reply with invalid CRC;180;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a7;STRH_FilePathTooLong;Received invalid path string. Exceeds allowed length;167;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b5;STRH_StrHelperExecuting;Star tracker handler currently executing a command and using the communication interface;181;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a8;STRH_FilenameTooLong;Name of file received with command is too long;168;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b6;STRH_StartrackerAlreadyBooted;Star tracker is already in firmware mode;182;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a9;STRH_InvalidProgram;Received version reply with invalid program ID;169;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b7;STRH_StartrackerNotRunningFirmware;Star tracker must be in firmware mode to run this command;183;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54aa;STRH_ReplyError;Status field reply signals error;170;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b8;STRH_StartrackerNotRunningBootloader;Star tracker must be in bootloader mode to run this command;184;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54ab;STRH_CommandTooShort;Received command which is too short (some data is missing for proper execution);171;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x58a0;SUSS_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;SUS_HANDLER;mission/acs/RwHandler.h
-0x54ac;STRH_InvalidLength;Received command with invalid length (too few or too many parameters);172;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x58a1;SUSS_InvalidRampTime;Action Message with invalid ramp time was received.;161;SUS_HANDLER;mission/acs/RwHandler.h
-0x54ad;STRH_RegionMismatch;Region mismatch between send and received data;173;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x58a2;SUSS_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;SUS_HANDLER;mission/acs/RwHandler.h
-0x54ae;STRH_AddressMismatch;Address mismatch between send and received data;174;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x58a3;SUSS_ExecutionFailed;Command execution failed;163;SUS_HANDLER;mission/acs/RwHandler.h
-0x54af;STRH_LengthMismatch;Length field mismatch between send and received data;175;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x58a4;SUSS_CrcError;Reaction wheel reply has invalid crc;164;SUS_HANDLER;mission/acs/RwHandler.h
-0x54b0;STRH_FileNotExists;Specified file does not exist;176;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x58a5;SUSS_ValueNotRead;No description;165;SUS_HANDLER;mission/acs/RwHandler.h
-0x54b1;STRH_InvalidType;Download blob pixel command has invalid type field;177;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x5d00;GOMS_PacketTooLong;No description;0;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x54b2;STRH_InvalidId;Received FPGA action command with invalid ID;178;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x5d01;GOMS_InvalidTableId;No description;1;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x54b3;STRH_ReplyTooShort;Received reply is too short;179;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x5d02;GOMS_InvalidAddress;No description;2;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x54b4;STRH_CrcFailure;Received reply with invalid CRC;180;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x5d03;GOMS_InvalidParamSize;No description;3;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x54b5;STRH_StrHelperExecuting;Star tracker handler currently executing a command and using the communication interface;181;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x5d04;GOMS_InvalidPayloadSize;No description;4;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x54b6;STRH_StartrackerAlreadyBooted;Star tracker is already in firmware mode;182;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x5d05;GOMS_UnknownReplyId;No description;5;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x54b7;STRH_StartrackerNotRunningFirmware;Star tracker must be in firmware mode to run this command;183;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x60a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/com/CcsdsIpCoreHandler.h
-0x54b8;STRH_StartrackerNotRunningBootloader;Star tracker must be in bootloader mode to run this command;184;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x6201;JSONBASE_JsonFileNotExists;Specified json file does not exist;1;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
-0x59a0;SUSS_ErrorUnlockMutex;No description;160;SUS_HANDLER;mission/acs/archive/LegacySusHandler.h
+0x6202;JSONBASE_SetNotExists;Requested set does not exist in json file;2;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
-0x59a1;SUSS_ErrorLockMutex;No description;161;SUS_HANDLER;mission/acs/archive/LegacySusHandler.h
+0x6203;JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
-0x5e00;GOMS_PacketTooLong;No description;0;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NvmParameterBase.h
-0x5e01;GOMS_InvalidTableId;No description;1;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x66a0;SADPL_CommandNotSupported;No description;160;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x5e02;GOMS_InvalidAddress;No description;2;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x66a1;SADPL_DeploymentAlreadyExecuting;No description;161;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x5e03;GOMS_InvalidParamSize;No description;3;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x66a2;SADPL_MainSwitchTimeoutFailure;No description;162;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x5e04;GOMS_InvalidPayloadSize;No description;4;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x66a3;SADPL_SwitchingDeplSa1Failed;No description;163;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x5e05;GOMS_UnknownReplyId;No description;5;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x66a4;SADPL_SwitchingDeplSa2Failed;No description;164;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x61a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/com/CcsdsIpCoreHandler.h
+0x6900;ACSCTRL_FileDeletionFailed;File deletion failed and at least one file is still existent.;0;ACS_CTRL;mission/controller/AcsController.h
-0x6301;JSONBASE_JsonFileNotExists;Specified json file does not exist;1;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
+0x6a02;ACSMEKF_MekfUninitialized;No description;2;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x6302;JSONBASE_SetNotExists;Requested set does not exist in json file;2;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
+0x6a03;ACSMEKF_MekfNoGyrData;No description;3;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x6303;JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
+0x6a04;ACSMEKF_MekfNoModelVectors;No description;4;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x64a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NvmParameterBase.h
+0x6a05;ACSMEKF_MekfNoSusMgmStrData;No description;5;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x67a0;SADPL_CommandNotSupported;No description;160;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x6a06;ACSMEKF_MekfCovarianceInversionFailed;No description;6;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x67a1;SADPL_DeploymentAlreadyExecuting;No description;161;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x6a07;ACSMEKF_MekfNotFinite;No description;7;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x67a2;SADPL_MainSwitchTimeoutFailure;No description;162;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x6a08;ACSMEKF_MekfInitialized;No description;8;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x67a3;SADPL_SwitchingDeplSa1Failed;No description;163;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x6a09;ACSMEKF_MekfRunning;No description;9;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x67a4;SADPL_SwitchingDeplSa2Failed;No description;164;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x6d00;PTM_DumpDone;No description;0;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
-0x6aa0;ACSCTRL_FileDeletionFailed;File deletion failed and at least one file is still existent.;160;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6d01;PTM_BusyDumping;No description;1;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
-0x6aa1;ACSCTRL_WriteFileFailed;Writing the TLE to the file has failed.;161;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6e00;TMS_IsBusy;No description;0;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x6aa2;ACSCTRL_ReadFileFailed;Reading the TLE to the file has failed.;162;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
 0x6aa3;ACSCTRL_SingleRwUnavailable;A single RW has failed.;163;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
 0x6aa4;ACSCTRL_MultipleRwUnavailable;Multiple RWs have failed.;164;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
 0x6b02;ACSMEKF_MekfUninitialized;No description;2;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6b03;ACSMEKF_MekfNoGyrData;No description;3;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6b04;ACSMEKF_MekfNoModelVectors;No description;4;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6b05;ACSMEKF_MekfNoSusMgmStrData;No description;5;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6b06;ACSMEKF_MekfCovarianceInversionFailed;No description;6;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6b07;ACSMEKF_MekfNotFinite;No description;7;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6b08;ACSMEKF_MekfInitialized;No description;8;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6b09;ACSMEKF_MekfRunning;No description;9;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
 0x6e00;PTM_DumpDone;No description;0;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
 0x6e01;PTM_BusyDumping;No description;1;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
 0x6f00;TMS_IsBusy;No description;0;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x6f01;TMS_PartiallyWritten;No description;1;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x6f02;TMS_NoWriteActive;No description;2;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x6f03;TMS_Timeout;No description;3;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x7000;VCS_ChannelDoesNotExist;No description;0;VIRTUAL_CHANNEL;mission/com/VirtualChannel.h
--- a/generators/bsp_hosted_subsystems.csv
+++ b/generators/bsp_hosted_subsystems.csv
@ -60,5 +60,3 @@
 142;COM_SUBSYSTEM
 143;PERSISTENT_TM_STORE
 144;SYRLINKS_COM
 145;SUS_HANDLER
 146;CFDP_APP
--- a/generators/bsp_q7s_events.csv
+++ b/generators/bsp_q7s_events.csv
@ -75,12 +75,9 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 7902;0x1ede;BIT_LOCK;INFO;A Bit Lock signal. Was detected. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7903;0x1edf;BIT_LOCK_LOST;INFO;A previously found Bit Lock signal was lost. P1: raw BLO state, P2: 0;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
 7905;0x1ee1;FRAME_PROCESSING_FAILED;LOW;The CCSDS Board could not interpret a TC;fsfw/src/fsfw/datalinklayer/DataLinkLayer.h
-8900;0x22c4;CLOCK_SET;INFO;Clock has been set. P1: old timeval seconds. P2: new timeval seconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8900;0x22c4;CLOCK_SET;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8901;0x22c5;CLOCK_DUMP_LEGACY;INFO;Clock dump event. P1: timeval seconds P2: timeval milliseconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8901;0x22c5;CLOCK_DUMP;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
-8902;0x22c6;CLOCK_SET_FAILURE;LOW;Clock could not be set. P1: Returncode.;fsfw/src/fsfw/pus/Service9TimeManagement.h
+8902;0x22c6;CLOCK_SET_FAILURE;LOW;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
 8903;0x22c7;CLOCK_DUMP;INFO;Clock dump event. P1: timeval seconds P2: timeval microseconds.;fsfw/src/fsfw/pus/Service9TimeManagement.h
 8904;0x22c8;CLOCK_DUMP_BEFORE_SETTING_TIME;INFO;No description;fsfw/src/fsfw/pus/Service9TimeManagement.h
 8905;0x22c9;CLOCK_DUMP_AFTER_SETTING_TIME;INFO;No description;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;No description;fsfw/src/fsfw/pus/Service17Test.h
 10600;0x2968;CHANGE_OF_SETUP_PARAMETER;LOW;No description;fsfw/src/fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h
@ -89,28 +86,19 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 10802;0x2a32;SERIALIZATION_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
 10803;0x2a33;FILESTORE_ERROR;LOW;No description;fsfw/src/fsfw/cfdp/handler/defs.h
 10804;0x2a34;FILENAME_TOO_LARGE_ERROR;LOW;P1: Transaction step ID, P2: 0 for source file name, 1 for dest file name;fsfw/src/fsfw/cfdp/handler/defs.h
 10805;0x2a35;HANDLING_CFDP_REQUEST_FAILED;LOW;CFDP request handling failed. P2: Returncode.;fsfw/src/fsfw/cfdp/handler/defs.h
 11200;0x2bc0;SAFE_RATE_VIOLATION;MEDIUM;The limits for the rotation in safe mode were violated.;mission/acs/defs.h
-11201;0x2bc1;RATE_RECOVERY;MEDIUM;The system has recovered from a rate rotation violation.;mission/acs/defs.h
+11201;0x2bc1;SAFE_RATE_RECOVERY;MEDIUM;The system has recovered from a safe rate rotation violation.;mission/acs/defs.h
 11202;0x2bc2;MULTIPLE_RW_INVALID;HIGH;Multiple RWs are invalid, uncommandable and therefore higher ACS modes cannot be maintained.;mission/acs/defs.h
 11203;0x2bc3;MEKF_INVALID_INFO;INFO;MEKF was not able to compute a solution. P1: MEKF state on exit;mission/acs/defs.h
 11204;0x2bc4;MEKF_RECOVERY;INFO;MEKF is able to compute a solution again.;mission/acs/defs.h
 11205;0x2bc5;MEKF_AUTOMATIC_RESET;INFO;MEKF performed an automatic reset after detection of nonfinite values.;mission/acs/defs.h
-11206;0x2bc6;PTG_CTRL_NO_ATTITUDE_INFORMATION;HIGH;For a prolonged time, no attitude information was available for the Pointing Controller. Falling back to Safe Mode.;mission/acs/defs.h
+11206;0x2bc6;MEKF_INVALID_MODE_VIOLATION;HIGH;MEKF was not able to compute a solution during any pointing ACS mode for a prolonged time.;mission/acs/defs.h
 11207;0x2bc7;SAFE_MODE_CONTROLLER_FAILURE;HIGH;The ACS safe mode controller was not able to compute a solution and has failed. P1: Missing information about magnetic field, P2: Missing information about rotational rate;mission/acs/defs.h
 11208;0x2bc8;TLE_TOO_OLD;INFO;The TLE for the SGP4 Propagator has become too old.;mission/acs/defs.h
 11209;0x2bc9;TLE_FILE_READ_FAILED;LOW;The TLE could not be read from the filesystem.;mission/acs/defs.h
 11210;0x2bca;PTG_RATE_VIOLATION;MEDIUM;The limits for the rotation in pointing mode were violated.;mission/acs/defs.h
 11211;0x2bcb;DETUMBLE_TRANSITION_FAILED;HIGH;The detumble transition has failed. //! P1: Last detumble state before failure.;mission/acs/defs.h
 11300;0x2c24;SWITCH_CMD_SENT;INFO;Indicates that a FSFW object requested setting a switch P1: 1 if on was requested, 0 for off | P2: Switch Index;mission/power/defs.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/power/defs.h
 11302;0x2c26;SWITCHING_Q7S_DENIED;MEDIUM;No description;mission/power/defs.h
 11303;0x2c27;FDIR_REACTION_IGNORED;MEDIUM;No description;mission/power/defs.h
 11304;0x2c28;DATASET_READ_FAILED;INFO;The dataset read for the inputs of the Power Controller has failed.;mission/power/defs.h
 11305;0x2c29;VOLTAGE_OUT_OF_BOUNDS;HIGH;No description;mission/power/defs.h
 11306;0x2c2a;TIMEDELTA_OUT_OF_BOUNDS;LOW;Time difference for Coulomb Counter was too large. P1: time in s * 10;mission/power/defs.h
 11307;0x2c2b;POWER_LEVEL_LOW;HIGH;The State of Charge is below the limit for payload use. Setting Payload to faulty.;mission/power/defs.h
 11308;0x2c2c;POWER_LEVEL_CRITICAL;HIGH;The State of Charge is below the limit for higher modes. Setting Reaction Wheels to faulty.;mission/power/defs.h
 11400;0x2c88;GPIO_PULL_HIGH_FAILED;LOW;No description;mission/tcs/HeaterHandler.h
 11401;0x2c89;GPIO_PULL_LOW_FAILED;LOW;No description;mission/tcs/HeaterHandler.h
 11402;0x2c8a;HEATER_WENT_ON;INFO;No description;mission/tcs/HeaterHandler.h
@ -128,15 +116,12 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11506;0x2cf2;DEPL_SA1_GPIO_SWTICH_OFF_FAILED;HIGH;No description;mission/SolarArrayDeploymentHandler.h
 11507;0x2cf3;DEPL_SA2_GPIO_SWTICH_OFF_FAILED;HIGH;No description;mission/SolarArrayDeploymentHandler.h
 11508;0x2cf4;AUTONOMOUS_DEPLOYMENT_COMPLETED;INFO;No description;mission/SolarArrayDeploymentHandler.h
-11601;0x2d51;MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC crc failure in telemetry packet;linux/payload/plocMpsocHelpers.h
+11601;0x2d51;MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC crc failure in telemetry packet;linux/payload/PlocMpsocHandler.h
-11602;0x2d52;ACK_FAILURE;LOW;PLOC receive acknowledgment failure report P1: Command Id which leads the acknowledgment failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/plocMpsocHelpers.h
+11602;0x2d52;ACK_FAILURE;LOW;PLOC receive acknowledgment failure report P1: Command Id which leads the acknowledgment failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/PlocMpsocHandler.h
-11603;0x2d53;EXE_FAILURE;LOW;PLOC receive execution failure report P1: Command Id which leads the execution failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/plocMpsocHelpers.h
+11603;0x2d53;EXE_FAILURE;LOW;PLOC receive execution failure report P1: Command Id which leads the execution failure report P2: The status field inserted by the MPSoC into the data field;linux/payload/PlocMpsocHandler.h
-11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/payload/plocMpsocHelpers.h
+11604;0x2d54;MPSOC_HANDLER_CRC_FAILURE;LOW;PLOC reply has invalid crc;linux/payload/PlocMpsocHandler.h
-11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/payload/plocMpsocHelpers.h
+11605;0x2d55;MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH;LOW;Packet sequence count in received space packet does not match expected count P1: Expected sequence count P2: Received sequence count;linux/payload/PlocMpsocHandler.h
-11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/payload/plocMpsocHelpers.h
+11606;0x2d56;MPSOC_SHUTDOWN_FAILED;HIGH;Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and thus also to shutdown the supervisor.;linux/payload/PlocMpsocHandler.h
 11607;0x2d57;SUPV_NOT_ON;LOW;SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for ON transition.;linux/payload/plocMpsocHelpers.h
 11608;0x2d58;SUPV_REPLY_TIMEOUT;LOW;SUPV reply timeout.;linux/payload/plocMpsocHelpers.h
 11609;0x2d59;CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE;LOW;Camera must be commanded on first.;linux/payload/plocMpsocHelpers.h
 11701;0x2db5;SELF_TEST_I2C_FAILURE;LOW;Get self test result returns I2C failure P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11702;0x2db6;SELF_TEST_SPI_FAILURE;LOW;Get self test result returns SPI failure. This concerns the MTM connectivity. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
 11703;0x2db7;SELF_TEST_ADC_FAILURE;LOW;Get self test result returns failure in measurement of current and temperature. P1: Indicates on which axis the failure occurred. 0 -> INIT, 1 -> +X, 2 -> -X, 3 -> +Y, 4 -> -Y, 5 -> +Z, 6 -> -Z, 7 -> FINA;mission/acs/ImtqHandler.h
@ -150,16 +135,14 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11901;0x2e7d;BOOTING_FIRMWARE_FAILED_EVENT;LOW;Failed to boot firmware;mission/acs/str/StarTrackerHandler.h
 11902;0x2e7e;BOOTING_BOOTLOADER_FAILED_EVENT;LOW;Failed to boot star tracker into bootloader mode;mission/acs/str/StarTrackerHandler.h
 11903;0x2e7f;COM_ERROR_REPLY_RECEIVED;LOW;Received COM error. P1:  Communication Error ID (datasheet p32);mission/acs/str/StarTrackerHandler.h
-12001;0x2ee1;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/payload/plocSupvDefs.h
+12001;0x2ee1;SUPV_MEMORY_READ_RPT_CRC_FAILURE;LOW;PLOC supervisor crc failure in telemetry packet;linux/payload/PlocSupervisorHandler.h
-12002;0x2ee2;SUPV_UNKNOWN_TM;LOW;Unhandled event. P1: APID, P2: Service ID;linux/payload/plocSupvDefs.h
+12002;0x2ee2;SUPV_UNKNOWN_TM;LOW;Unhandled event. P1: APID, P2: Service ID;linux/payload/PlocSupervisorHandler.h
-12003;0x2ee3;SUPV_UNINIMPLEMENTED_TM;LOW;No description;linux/payload/plocSupvDefs.h
+12003;0x2ee3;SUPV_UNINIMPLEMENTED_TM;LOW;No description;linux/payload/PlocSupervisorHandler.h
-12004;0x2ee4;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/payload/plocSupvDefs.h
+12004;0x2ee4;SUPV_ACK_FAILURE;LOW;PLOC supervisor received acknowledgment failure report;linux/payload/PlocSupervisorHandler.h
-12005;0x2ee5;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report P1: ID of command for which the execution failed P2: Status code sent by the supervisor handler;linux/payload/plocSupvDefs.h
+12005;0x2ee5;SUPV_EXE_FAILURE;LOW;PLOC received execution failure report P1: ID of command for which the execution failed P2: Status code sent by the supervisor handler;linux/payload/PlocSupervisorHandler.h
-12006;0x2ee6;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/payload/plocSupvDefs.h
+12006;0x2ee6;SUPV_CRC_FAILURE_EVENT;LOW;PLOC supervisor reply has invalid crc;linux/payload/PlocSupervisorHandler.h
-12007;0x2ee7;SUPV_HELPER_EXECUTING;LOW;Supervisor helper currently executing a command;linux/payload/plocSupvDefs.h
+12007;0x2ee7;SUPV_HELPER_EXECUTING;LOW;Supervisor helper currently executing a command;linux/payload/PlocSupervisorHandler.h
-12008;0x2ee8;SUPV_MPSOC_SHUTDOWN_BUILD_FAILED;LOW;Failed to build the command to shutdown the MPSoC;linux/payload/plocSupvDefs.h
+12008;0x2ee8;SUPV_MPSOC_SHUTDOWN_BUILD_FAILED;LOW;Failed to build the command to shutdown the MPSoC;linux/payload/PlocSupervisorHandler.h
 12009;0x2ee9;SUPV_ACK_UNKNOWN_COMMAND;LOW;Received ACK, but no related command is unknown or has not been sent  by this software instance. P1: Module APID. P2: Service ID.;linux/payload/plocSupvDefs.h
 12010;0x2eea;SUPV_EXE_ACK_UNKNOWN_COMMAND;LOW;Received ACK EXE, but no related command is unknown or has not been sent  by this software instance. P1: Module APID. P2: Service ID.;linux/payload/plocSupvDefs.h
 12100;0x2f44;SANITIZATION_FAILED;LOW;No description;bsp_q7s/fs/SdCardManager.h
 12101;0x2f45;MOUNTED_SD_CARD;INFO;No description;bsp_q7s/fs/SdCardManager.h
 12300;0x300c;SEND_MRAM_DUMP_FAILED;LOW;Failed to send mram dump command to supervisor handler P1: Return value of commandAction function P2: Start address of MRAM to dump with this command;linux/payload/PlocMemoryDumper.h
@ -237,9 +220,8 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 12902;0x3266;POWER_STATE_MACHINE_TIMEOUT;MEDIUM;No description;mission/system/acs/SusAssembly.h
 12903;0x3267;SIDE_SWITCH_TRANSITION_NOT_ALLOWED;LOW;Not implemented, would increase already high complexity. Operator should instead command the assembly off first and then command the assembly on into the desired mode/submode combination;mission/system/acs/SusAssembly.h
 13000;0x32c8;CHILDREN_LOST_MODE;MEDIUM;No description;mission/system/tcs/TcsBoardAssembly.h
-13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: New fix. P2: Missed fix changes 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;linux/acs/GPSDefinitions.h
+13100;0x332c;GPS_FIX_CHANGE;INFO;Fix has changed. P1: Old fix. P2: New fix 0: Not seen, 1: No Fix, 2: 2D-Fix, 3: 3D-Fix;mission/acs/archive/GPSDefinitions.h
-13101;0x332d;CANT_GET_FIX;MEDIUM;Could not get fix in maximum allowed time. Trying to reset both GNSS devices. P1: Maximum allowed time to get a fix after the GPS was switched on.;linux/acs/GPSDefinitions.h
+13101;0x332d;CANT_GET_FIX;LOW;Could not get fix in maximum allowed time. P1: Maximum allowed time to get a fix after the GPS was switched on.;mission/acs/archive/GPSDefinitions.h
 13102;0x332e;RESET_FAIL;HIGH;Failed to reset an GNNS Device. P1: Board-Side.;linux/acs/GPSDefinitions.h
 13200;0x3390;P60_BOOT_COUNT;INFO;P60 boot count is broadcasted once at SW startup. P1: Boot count;mission/power/P60DockHandler.h
 13201;0x3391;BATT_MODE;INFO;Battery mode is broadcasted at startup. P1: Mode;mission/power/P60DockHandler.h
 13202;0x3392;BATT_MODE_CHANGED;MEDIUM;Battery mode has changed. P1: Old mode. P2: New mode;mission/power/P60DockHandler.h
@ -321,6 +303,3 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14312;0x37e8;DUMP_MISC_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14313;0x37e9;DUMP_HK_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14314;0x37ea;DUMP_CFDP_CANCELLED;LOW;P1: Number of dumped packets. P2: Total dumped bytes.;mission/persistentTmStoreDefs.h
 14500;0x38a4;TEMPERATURE_ALL_ONES_START;MEDIUM;Detected invalid values, starting invalid message counting;mission/acs/SusHandler.h
 14501;0x38a5;TEMPERATURE_ALL_ONES_RECOVERY;INFO;Detected valid values for a prolonged time again, resetting all counters. P1: Number of periods with invalid messages. P2: Maximum invalid message counter.;mission/acs/SusHandler.h
 14600;0x3908;FAULT_HANDLER_TRIGGERED;LOW;P1: CFDP fault handler code. P2: CFDP condition code.;mission/cfdp/defs.h
--- a/generators/bsp_q7s_objects.csv
+++ b/generators/bsp_q7s_objects.csv
@ -1,9 +1,7 @@
 0x00005060;P60DOCK_TEST_TASK
 0x43000002;ACS_CONTROLLER
 0x43000003;CORE_CONTROLLER
 0x43000004;POWER_CONTROLLER
 0x43000006;GLOBAL_JSON_CFG
 0x43000007;XIPHOS_WDT
 0x43400001;THERMAL_CONTROLLER
 0x44120006;MGM_0_LIS3_HANDLER
 0x44120010;GYRO_0_ADIS_HANDLER
@ -56,7 +54,6 @@
 0x44330015;PLOC_MPSOC_HANDLER
 0x44330016;PLOC_SUPERVISOR_HANDLER
 0x44330017;PLOC_SUPERVISOR_HELPER
 0x44330018;PLOC_MPSOC_COMMUNICATION
 0x44330032;SCEX
 0x444100A2;SOLAR_ARRAY_DEPL_HANDLER
 0x444100A4;HEATER_HANDLER
@ -159,13 +156,11 @@
 0x73000102;CFDP_TM_FUNNEL
 0x73000205;CFDP_HANDLER
 0x73000206;CFDP_DISTRIBUTOR
 0x73000207;CFDP_FAULT_HANDLER
 0x73010000;EIVE_SYSTEM
 0x73010001;ACS_SUBSYSTEM
 0x73010002;PL_SUBSYSTEM
 0x73010003;TCS_SUBSYSTEM
 0x73010004;COM_SUBSYSTEM
 0x73010005;EPS_SUBSYSTEM
 0x73020001;MISC_TM_STORE
 0x73020002;OK_TM_STORE
 0x73020003;NOT_OK_TM_STORE
--- a/generators/bsp_q7s_returnvalues.csv
+++ b/generators/bsp_q7s_returnvalues.csv
@ -210,7 +210,6 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x27a8;DHI_NoReplyExpected;No description;168;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27a9;DHI_NonOpTemperature;No description;169;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27aa;DHI_CommandNotImplemented;No description;170;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27ab;DHI_NonOpStateOfCharge;No description;171;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b0;DHI_ChecksumError;No description;176;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b1;DHI_LengthMissmatch;No description;177;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
 0x27b2;DHI_InvalidData;No description;178;DEVICE_HANDLER_IF;fsfw/src/fsfw/devicehandlers/DeviceHandlerIF.h
@ -323,311 +322,289 @@ Full ID (hex); Name; Description; Unique ID; Subsytem Name; File Path
 0x3405;DC_NotActive;No description;5;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
 0x3406;DC_TooMuchData;No description;6;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
 0x3407;DC_Busy;No description;7;DEVICE_COMMUNICATION_IF;fsfw/src/fsfw/devicehandlers/DeviceCommunicationIF.h
-0x3601;CFDP_InvalidTlvType;No description;1;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3601;CFDP_InvalidTlvType;No description;1;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3602;CFDP_InvalidDirectiveField;No description;2;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3602;CFDP_InvalidDirectiveField;No description;2;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3603;CFDP_InvalidPduDatafieldLen;No description;3;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3603;CFDP_InvalidPduDatafieldLen;No description;3;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3604;CFDP_InvalidAckDirectiveFields;No description;4;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3604;CFDP_InvalidAckDirectiveFields;No description;4;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3605;CFDP_MetadataCantParseOptions;No description;5;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3605;CFDP_MetadataCantParseOptions;No description;5;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3606;CFDP_NakCantParseOptions;No description;6;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3606;CFDP_NakCantParseOptions;No description;6;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3607;CFDP_FinishedCantParseFsResponses;No description;7;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3607;CFDP_FinishedCantParseFsResponses;No description;7;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3608;CFDP_FilestoreRequiresSecondFile;No description;8;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3608;CFDP_FilestoreRequiresSecondFile;No description;8;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3609;CFDP_FilestoreResponseCantParseFsMessage;No description;9;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x3609;CFDP_FilestoreResponseCantParseFsMessage;No description;9;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x360a;CFDP_InvalidPduFormat;No description;10;CFDP_BASE;fsfw/src/fsfw/cfdp/definitions.h
+0x360a;CFDP_InvalidPduFormat;No description;10;CFDP;fsfw/src/fsfw/cfdp/definitions.h
-0x3700;CFDP_SourceTransactionPending;No description;0;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x3701;TSI_BadTimestamp;No description;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
-0x3701;CFDP_FileDoesNotExist;No description;1;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38a1;SGP4_InvalidEccentricity;No description;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3702;CFDP_FileSegmentLenInvalid;No description;2;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38a2;SGP4_InvalidMeanMotion;No description;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3703;CFDP_SourceNameEmpty;No description;3;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38a3;SGP4_InvalidPerturbationElements;No description;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3704;CFDP_DestNameEmpty;No description;4;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38a4;SGP4_InvalidSemiLatusRectum;No description;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3705;CFDP_WrongRemoteCfgEntityId;No description;5;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38a5;SGP4_InvalidEpochElements;No description;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3706;CFDP_TargetMsgQueueFull;No description;6;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38a6;SGP4_SatelliteHasDecayed;No description;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3707;CFDP_TmStoreFull;No description;7;CFDP_HANDLER;fsfw/src/fsfw/cfdp/handler/defs.h
+0x38b1;SGP4_TleTooOld;No description;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x3801;TSI_BadTimestamp;No description;1;TIME_STAMPER_IF;fsfw/src/fsfw/timemanager/TimeStampIF.h
+0x38b2;SGP4_TleNotInitialized;No description;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
-0x39a1;SGP4_InvalidEccentricity;No description;161;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3901;MUX_NotEnoughResources;No description;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39a2;SGP4_InvalidMeanMotion;No description;162;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3902;MUX_InsufficientMemory;No description;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39a3;SGP4_InvalidPerturbationElements;No description;163;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3903;MUX_NoPrivilege;No description;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39a4;SGP4_InvalidSemiLatusRectum;No description;164;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3904;MUX_WrongAttributeSetting;No description;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39a5;SGP4_InvalidEpochElements;No description;165;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3905;MUX_MutexAlreadyLocked;No description;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39a6;SGP4_SatelliteHasDecayed;No description;166;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3906;MUX_MutexNotFound;No description;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39b1;SGP4_TleTooOld;No description;177;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3907;MUX_MutexMaxLocks;No description;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x39b2;SGP4_TleNotInitialized;No description;178;SGP4PROPAGATOR_CLASS;fsfw/src/fsfw/coordinates/Sgp4Propagator.h
+0x3908;MUX_CurrThreadAlreadyOwnsMutex;No description;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3a01;MUX_NotEnoughResources;No description;1;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3909;MUX_CurrThreadDoesNotOwnMutex;No description;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3a02;MUX_InsufficientMemory;No description;2;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x390a;MUX_MutexTimeout;No description;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3a03;MUX_NoPrivilege;No description;3;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x390b;MUX_MutexInvalidId;No description;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3a04;MUX_WrongAttributeSetting;No description;4;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x390c;MUX_MutexDestroyedWhileWaiting;No description;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
-0x3a05;MUX_MutexAlreadyLocked;No description;5;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a01;MQI_Empty;No description;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a06;MUX_MutexNotFound;No description;6;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a07;MUX_MutexMaxLocks;No description;7;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a08;MUX_CurrThreadAlreadyOwnsMutex;No description;8;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3a04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
-0x3a09;MUX_CurrThreadDoesNotOwnMutex;No description;9;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3b01;SPH_SemaphoreTimeout;No description;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3a0a;MUX_MutexTimeout;No description;10;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3b02;SPH_SemaphoreNotOwned;No description;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3a0b;MUX_MutexInvalidId;No description;11;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3b03;SPH_SemaphoreInvalid;No description;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
-0x3a0c;MUX_MutexDestroyedWhileWaiting;No description;12;MUTEX_IF;fsfw/src/fsfw/ipc/MutexIF.h
+0x3c00;LPIF_PoolEntryNotFound;No description;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
-0x3b01;MQI_Empty;No description;1;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3c01;LPIF_PoolEntryTypeConflict;No description;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
-0x3b02;MQI_Full;No space left for more messages;2;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3da0;PVA_InvalidReadWriteMode;No description;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
-0x3b03;MQI_NoReplyPartner;Returned if a reply method was called without partner;3;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3da1;PVA_InvalidPoolEntry;No description;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
-0x3b04;MQI_DestinationInvalid;Returned if the target destination is invalid.;4;MESSAGE_QUEUE_IF;fsfw/src/fsfw/ipc/MessageQueueIF.h
+0x3e00;HKM_QueueOrDestinationInvalid;No description;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3c01;SPH_SemaphoreTimeout;No description;1;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3e01;HKM_WrongHkPacketType;No description;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3c02;SPH_SemaphoreNotOwned;No description;2;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3e02;HKM_ReportingStatusUnchanged;No description;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3c03;SPH_SemaphoreInvalid;No description;3;SEMAPHORE_IF;fsfw/src/fsfw/tasks/SemaphoreIF.h
+0x3e03;HKM_PeriodicHelperInvalid;No description;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d00;LPIF_PoolEntryNotFound;No description;0;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3e04;HKM_PoolobjectNotFound;No description;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3d01;LPIF_PoolEntryTypeConflict;No description;1;LOCAL_POOL_OWNER_IF;fsfw/src/fsfw/datapoollocal/localPoolDefinitions.h
+0x3e05;HKM_DatasetNotFound;No description;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
-0x3ea0;PVA_InvalidReadWriteMode;No description;160;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
+0x3f01;DLEE_StreamTooShort;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x3ea1;PVA_InvalidPoolEntry;No description;161;POOL_VARIABLE_IF;fsfw/src/fsfw/datapool/PoolVariableIF.h
+0x3f02;DLEE_DecodingError;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
-0x3f00;HKM_QueueOrDestinationInvalid;No description;0;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4100;PUS9_ConnBroken;No description;0;PUS_SERVICE_9;fsfw/src/fsfw/osal/common/TcpTmTcServer.h
-0x3f01;HKM_WrongHkPacketType;No description;1;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4201;PUS11_InvalidTypeTimeWindow;No description;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x3f02;HKM_ReportingStatusUnchanged;No description;2;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4202;PUS11_InvalidTimeWindow;No description;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x3f03;HKM_PeriodicHelperInvalid;No description;3;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4203;PUS11_TimeshiftingNotPossible;No description;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x3f04;HKM_PoolobjectNotFound;No description;4;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4204;PUS11_InvalidRelativeTime;No description;4;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x3f05;HKM_DatasetNotFound;No description;5;HOUSEKEEPING_MANAGER;fsfw/src/fsfw/datapoollocal/LocalDataPoolManager.h
+0x4205;PUS11_ContainedTcTooSmall;No description;5;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4001;DLEE_StreamTooShort;No description;1;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x4206;PUS11_ContainedTcCrcMissmatch;No description;6;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
-0x4002;DLEE_DecodingError;No description;2;DLE_ENCODER;fsfw/src/fsfw/globalfunctions/DleEncoder.h
+0x4300;FILS_GenericFileError;No description;0;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4301;PUS11_InvalidTypeTimeWindow;No description;1;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4301;FILS_GenericDirError;No description;1;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4302;PUS11_InvalidTimeWindow;No description;2;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4302;FILS_FilesystemInactive;No description;2;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4303;PUS11_TimeshiftingNotPossible;No description;3;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4303;FILS_GenericRenameError;No description;3;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4304;PUS11_InvalidRelativeTime;No description;4;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4304;FILS_IsBusy;No description;4;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4305;PUS11_ContainedTcTooSmall;No description;5;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x4305;FILS_InvalidParameters;No description;5;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4306;PUS11_ContainedTcCrcMissmatch;No description;6;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x430a;FILS_FileDoesNotExist;No description;10;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4307;PUS11_MapIsFull;No description;7;PUS_SERVICE_11;fsfw/src/fsfw/pus/Service11TelecommandScheduling.h
+0x430b;FILS_FileAlreadyExists;No description;11;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4400;FILS_GenericFileError;No description;0;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430c;FILS_NotAFile;No description;12;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4401;FILS_GenericDirError;No description;1;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430d;FILS_FileLocked;No description;13;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4402;FILS_FilesystemInactive;No description;2;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x430e;FILS_PermissionDenied;No description;14;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4403;FILS_GenericRenameError;No description;3;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4315;FILS_DirectoryDoesNotExist;No description;21;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4404;FILS_IsBusy;No description;4;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4316;FILS_DirectoryAlreadyExists;No description;22;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x4405;FILS_InvalidParameters;No description;5;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4317;FILS_NotADirectory;No description;23;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x440a;FILS_FileDoesNotExist;No description;10;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4318;FILS_DirectoryNotEmpty;No description;24;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x440b;FILS_FileAlreadyExists;No description;11;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x431e;FILS_SequencePacketMissingWrite;No description;30;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x440c;FILS_NotAFile;No description;12;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x431f;FILS_SequencePacketMissingRead;No description;31;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
-0x440d;FILS_FileLocked;No description;13;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4400;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x440e;FILS_PermissionDenied;No description;14;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4401;UXOS_CommandPending;Command is pending. This will also be returned if the user tries to load another command but a command is still pending;1;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4415;FILS_DirectoryDoesNotExist;No description;21;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4402;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4416;FILS_DirectoryAlreadyExists;No description;22;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4403;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4417;FILS_NotADirectory;No description;23;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4404;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x4418;FILS_DirectoryNotEmpty;No description;24;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4406;UXOS_PcloseCallError;No description;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
-0x441e;FILS_SequencePacketMissingWrite;No description;30;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4500;HSPI_HalTimeoutRetval;No description;0;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x441f;FILS_SequencePacketMissingRead;No description;31;FILE_SYSTEM;fsfw/src/fsfw/filesystem/HasFileSystemIF.h
+0x4501;HSPI_HalBusyRetval;No description;1;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x4500;UXOS_ExecutionFinished;Execution of the current command has finished;0;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4502;HSPI_HalErrorRetval;No description;2;HAL_SPI;fsfw/src/fsfw_hal/stm32h7/spi/spiDefinitions.h
-0x4501;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
+0x4503;HSPI_Timeout;No description;3;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4502;UXOS_BytesRead;Some bytes have been read from the executing process;2;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4504;HSPI_Busy;No description;4;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4503;UXOS_CommandError;Command execution failed;3;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4505;HSPI_GenericError;No description;5;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
-0x4504;UXOS_NoCommandLoadedOrPending;;4;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4601;HURT_UartReadFailure;No description;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4506;UXOS_PcloseCallError;No description;6;LINUX_OSAL;fsfw/src/fsfw_hal/linux/CommandExecutor.h
+0x4602;HURT_UartReadSizeMissmatch;No description;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4600;HSPI_OpeningFileFailed;No description;0;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4603;HURT_UartRxBufferTooSmall;No description;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
-0x4601;HSPI_FullDuplexTransferFailed;No description;1;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4801;HGIO_UnknownGpioId;No description;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4602;HSPI_HalfDuplexTransferFailed;No description;2;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4802;HGIO_DriveGpioFailure;No description;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4603;HSPI_Timeout;No description;3;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4803;HGIO_GpioTypeFailure;No description;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4604;HSPI_Busy;No description;4;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4804;HGIO_GpioInvalidInstance;No description;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4605;HSPI_GenericError;No description;5;HAL_SPI;fsfw/src/fsfw_hal/common/spi/spiCommon.h
+0x4805;HGIO_GpioDuplicateDetected;No description;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4701;HURT_UartReadFailure;No description;1;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4806;HGIO_GpioInitFailed;No description;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4702;HURT_UartReadSizeMissmatch;No description;2;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4807;HGIO_GpioGetValueFailed;No description;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
-0x4703;HURT_UartRxBufferTooSmall;No description;3;HAL_UART;fsfw/src/fsfw_hal/linux/serial/SerialComIF.h
+0x4c00;SPPA_NoPacketFound;No description;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x4901;HGIO_UnknownGpioId;No description;1;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4c01;SPPA_SplitPacket;No description;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
-0x4902;HGIO_DriveGpioFailure;No description;2;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4fa1;HEATER_CommandNotSupported;No description;161;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4903;HGIO_GpioTypeFailure;No description;3;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4fa2;HEATER_InitFailed;No description;162;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4904;HGIO_GpioInvalidInstance;No description;4;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4fa3;HEATER_InvalidSwitchNr;No description;163;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4905;HGIO_GpioDuplicateDetected;No description;5;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4fa4;HEATER_MainSwitchSetTimeout;No description;164;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4906;HGIO_GpioInitFailed;No description;6;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x4fa5;HEATER_CommandAlreadyWaiting;No description;165;HEATER_HANDLER;mission/tcs/HeaterHandler.h
-0x4907;HGIO_GpioGetValueFailed;No description;7;HAL_GPIO;fsfw/src/fsfw_hal/linux/gpio/LinuxLibgpioIF.h
+0x50a0;SYRLINKS_CrcFailure;No description;160;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x4d00;SPPA_NoPacketFound;No description;0;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x50a1;SYRLINKS_UartFraminOrParityErrorAck;No description;161;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x4d01;SPPA_SplitPacket;No description;1;SPACE_PACKET_PARSER;fsfw/src/fsfw/tmtcservices/SpacePacketParser.h
+0x50a2;SYRLINKS_BadCharacterAck;No description;162;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a1;HEATER_CommandNotSupported;No description;161;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a3;SYRLINKS_BadParameterValueAck;No description;163;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a2;HEATER_InitFailed;No description;162;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a4;SYRLINKS_BadEndOfFrameAck;No description;164;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a3;HEATER_InvalidSwitchNr;No description;163;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a5;SYRLINKS_UnknownCommandIdAck;No description;165;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a4;HEATER_MainSwitchSetTimeout;No description;164;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a6;SYRLINKS_BadCrcAck;No description;166;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x50a5;HEATER_CommandAlreadyWaiting;No description;165;HEATER_HANDLER;mission/tcs/HeaterHandler.h
+0x50a7;SYRLINKS_ReplyWrongSize;No description;167;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x51a0;SYRLINKS_CrcFailure;No description;160;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x50a8;SYRLINKS_MissingStartFrameCharacter;No description;168;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
-0x51a1;SYRLINKS_UartFraminOrParityErrorAck;No description;161;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5100;IMTQ_InvalidCommandCode;No description;0;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a2;SYRLINKS_BadCharacterAck;No description;162;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5101;IMTQ_MgmMeasurementLowLevelError;No description;1;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a3;SYRLINKS_BadParameterValueAck;No description;163;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5102;IMTQ_ActuateCmdLowLevelError;No description;2;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a4;SYRLINKS_BadEndOfFrameAck;No description;164;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5103;IMTQ_ParameterMissing;No description;3;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a5;SYRLINKS_UnknownCommandIdAck;No description;165;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5104;IMTQ_ParameterInvalid;No description;4;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a6;SYRLINKS_BadCrcAck;No description;166;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5105;IMTQ_CcUnavailable;No description;5;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a7;SYRLINKS_ReplyWrongSize;No description;167;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5106;IMTQ_InternalProcessingError;No description;6;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x51a8;SYRLINKS_MissingStartFrameCharacter;No description;168;SYRLINKS_HANDLER;mission/com/SyrlinksHandler.h
+0x5107;IMTQ_RejectedWithoutReason;No description;7;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5200;IMTQ_InvalidCommandCode;No description;0;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5108;IMTQ_CmdErrUnknown;No description;8;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5201;IMTQ_MgmMeasurementLowLevelError;No description;1;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x5109;IMTQ_StartupCfgError;No description;9;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5202;IMTQ_ActuateCmdLowLevelError;No description;2;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x510a;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.;10;IMTQ_HANDLER;mission/acs/imtqHelpers.h
-0x5203;IMTQ_ParameterMissing;No description;3;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b0;RWHA_SpiWriteFailure;No description;176;RW_HANDLER;mission/acs/rwHelpers.h
-0x5204;IMTQ_ParameterInvalid;No description;4;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/acs/rwHelpers.h
-0x5205;IMTQ_CcUnavailable;No description;5;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/acs/rwHelpers.h
-0x5206;IMTQ_InternalProcessingError;No description;6;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b3;RWHA_InvalidSubstitute;Can be used by the HDLC decoding mechanism to inform about an invalid substitution combination;179;RW_HANDLER;mission/acs/rwHelpers.h
-0x5207;IMTQ_RejectedWithoutReason;No description;7;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b4;RWHA_MissingEndSign;HDLC decoding mechanism never receives the end sign 0x7E;180;RW_HANDLER;mission/acs/rwHelpers.h
-0x5208;IMTQ_CmdErrUnknown;No description;8;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/acs/rwHelpers.h
-0x5209;IMTQ_StartupCfgError;No description;9;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/acs/rwHelpers.h
-0x520a;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.;10;IMTQ_HANDLER;mission/acs/imtqHelpers.h
+0x52b7;RWHA_SpiReadTimeout;Timeout when reading reply;183;RW_HANDLER;mission/acs/rwHelpers.h
-0x53a0;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/acs/RwHandler.h
+0x53a0;STRH_TemperatureReqFailed;Status in temperature reply signals error;160;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a1;RWHA_InvalidRampTime;Action Message with invalid ramp time was received.;161;RW_HANDLER;mission/acs/RwHandler.h
+0x53a1;STRH_PingFailed;Ping command failed;161;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a2;RWHA_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;RW_HANDLER;mission/acs/RwHandler.h
+0x53a2;STRH_VersionReqFailed;Status in version reply signals error;162;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a3;RWHA_ExecutionFailed;Command execution failed;163;RW_HANDLER;mission/acs/RwHandler.h
+0x53a3;STRH_InterfaceReqFailed;Status in interface reply signals error;163;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a4;RWHA_CrcError;Reaction wheel reply has invalid crc;164;RW_HANDLER;mission/acs/RwHandler.h
+0x53a4;STRH_PowerReqFailed;Status in power reply signals error;164;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53a5;RWHA_ValueNotRead;No description;165;RW_HANDLER;mission/acs/RwHandler.h
+0x53a5;STRH_SetParamFailed;Status of reply to parameter set command signals error;165;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b0;RWHA_SpiWriteFailure;No description;176;RW_HANDLER;mission/acs/rwHelpers.h
+0x53a6;STRH_ActionFailed;Status of reply to action command signals error;166;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b1;RWHA_SpiReadFailure;Used by the spi send function to tell a failing read call;177;RW_HANDLER;mission/acs/rwHelpers.h
+0x53a7;STRH_FilePathTooLong;Received invalid path string. Exceeds allowed length;167;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b2;RWHA_MissingStartSign;Can be used by the HDLC decoding mechanism to inform about a missing start sign 0x7E;178;RW_HANDLER;mission/acs/rwHelpers.h
+0x53a8;STRH_FilenameTooLong;Name of file received with command is too long;168;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b3;RWHA_InvalidSubstitute;Can be used by the HDLC decoding mechanism to inform about an invalid substitution combination;179;RW_HANDLER;mission/acs/rwHelpers.h
+0x53a9;STRH_InvalidProgram;Received version reply with invalid program ID;169;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b4;RWHA_MissingEndSign;HDLC decoding mechanism never receives the end sign 0x7E;180;RW_HANDLER;mission/acs/rwHelpers.h
+0x53aa;STRH_ReplyError;Status field reply signals error;170;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b5;RWHA_NoReply;Reaction wheel only responds with empty frames.;181;RW_HANDLER;mission/acs/rwHelpers.h
+0x53ab;STRH_CommandTooShort;Received command which is too short (some data is missing for proper execution);171;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b6;RWHA_NoStartMarker;Expected a start marker as first byte;182;RW_HANDLER;mission/acs/rwHelpers.h
+0x53ac;STRH_InvalidLength;Received command with invalid length (too few or too many parameters);172;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x53b7;RWHA_SpiReadTimeout;Timeout when reading reply;183;RW_HANDLER;mission/acs/rwHelpers.h
+0x53ad;STRH_RegionMismatch;Region mismatch between send and received data;173;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a0;STRH_TemperatureReqFailed;Status in temperature reply signals error;160;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53ae;STRH_AddressMismatch;Address mismatch between send and received data;174;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a1;STRH_PingFailed;Ping command failed;161;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53af;STRH_LengthMismatch;Length field mismatch between send and received data;175;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a2;STRH_VersionReqFailed;Status in version reply signals error;162;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b0;STRH_FileNotExists;Specified file does not exist;176;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a3;STRH_InterfaceReqFailed;Status in interface reply signals error;163;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b1;STRH_InvalidType;Download blob pixel command has invalid type field;177;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a4;STRH_PowerReqFailed;Status in power reply signals error;164;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b2;STRH_InvalidId;Received FPGA action command with invalid ID;178;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a5;STRH_SetParamFailed;Status of reply to parameter set command signals error;165;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b3;STRH_ReplyTooShort;Received reply is too short;179;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a6;STRH_ActionFailed;Status of reply to action command signals error;166;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b4;STRH_CrcFailure;Received reply with invalid CRC;180;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a7;STRH_FilePathTooLong;Received invalid path string. Exceeds allowed length;167;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b5;STRH_StrHelperExecuting;Star tracker handler currently executing a command and using the communication interface;181;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a8;STRH_FilenameTooLong;Name of file received with command is too long;168;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b6;STRH_StartrackerAlreadyBooted;Star tracker is already in firmware mode;182;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54a9;STRH_InvalidProgram;Received version reply with invalid program ID;169;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b7;STRH_StartrackerNotRunningFirmware;Star tracker must be in firmware mode to run this command;183;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54aa;STRH_ReplyError;Status field reply signals error;170;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x53b8;STRH_StartrackerNotRunningBootloader;Star tracker must be in bootloader mode to run this command;184;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
-0x54ab;STRH_CommandTooShort;Received command which is too short (some data is missing for proper execution);171;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54e0;DWLPWRON_InvalidMode;Received command has invalid JESD mode (valid modes are 0 - 5);224;DWLPWRON_CMD;linux/payload/plocMpsocHelpers.h
-0x54ac;STRH_InvalidLength;Received command with invalid length (too few or too many parameters);172;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x54e1;DWLPWRON_InvalidLaneRate;Received command has invalid lane rate (valid lane rate are 0 - 9);225;DWLPWRON_CMD;linux/payload/plocMpsocHelpers.h
-0x54ad;STRH_RegionMismatch;Region mismatch between send and received data;173;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x5700;PLSPVhLP_RequestDone;No description;0;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x54ae;STRH_AddressMismatch;Address mismatch between send and received data;174;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x5701;PLSPVhLP_NoPacketFound;No description;1;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x54af;STRH_LengthMismatch;Length field mismatch between send and received data;175;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x5702;PLSPVhLP_DecodeBufTooSmall;No description;2;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x54b0;STRH_FileNotExists;Specified file does not exist;176;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x5703;PLSPVhLP_PossiblePacketLossConsecutiveStart;No description;3;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x54b1;STRH_InvalidType;Download blob pixel command has invalid type field;177;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x5704;PLSPVhLP_PossiblePacketLossConsecutiveEnd;No description;4;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x54b2;STRH_InvalidId;Received FPGA action command with invalid ID;178;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x5705;PLSPVhLP_HdlcError;No description;5;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x54b3;STRH_ReplyTooShort;Received reply is too short;179;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x57a0;PLSPVhLP_FileClosedAccidentally;File accidentally close;160;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x54b4;STRH_CrcFailure;Received reply with invalid CRC;180;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x57a1;PLSPVhLP_ProcessTerminated;Process has been terminated by command;161;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x54b5;STRH_StrHelperExecuting;Star tracker handler currently executing a command and using the communication interface;181;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x57a2;PLSPVhLP_PathNotExists;Received command with invalid pathname;162;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x54b6;STRH_StartrackerAlreadyBooted;Star tracker is already in firmware mode;182;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x57a3;PLSPVhLP_EventBufferReplyInvalidApid;Expected event buffer TM but received space packet with other APID;163;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
-0x54b7;STRH_StartrackerNotRunningFirmware;Star tracker must be in firmware mode to run this command;183;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x58a0;SUSS_InvalidSpeed;Action Message with invalid speed was received. Valid speeds must be in the range of [-65000, 1000] or [1000, 65000];160;SUS_HANDLER;mission/acs/RwHandler.h
-0x54b8;STRH_StartrackerNotRunningBootloader;Star tracker must be in bootloader mode to run this command;184;STR_HANDLER;mission/acs/str/StarTrackerHandler.h
+0x58a1;SUSS_InvalidRampTime;Action Message with invalid ramp time was received.;161;SUS_HANDLER;mission/acs/RwHandler.h
-0x55e0;DWLPWRON_InvalidMode;Received command has invalid JESD mode (valid modes are 0 - 5);224;DWLPWRON_CMD;linux/payload/plocMpsocHelpers.h
+0x58a2;SUSS_SetSpeedCommandInvalidLength;Received set speed command has invalid length. Should be 6.;162;SUS_HANDLER;mission/acs/RwHandler.h
-0x55e1;DWLPWRON_InvalidLaneRate;Received command has invalid lane rate (valid lane rate are 0 - 9);225;DWLPWRON_CMD;linux/payload/plocMpsocHelpers.h
+0x58a3;SUSS_ExecutionFailed;Command execution failed;163;SUS_HANDLER;mission/acs/RwHandler.h
-0x5800;PLSPVhLP_RequestDone;No description;0;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x58a4;SUSS_CrcError;Reaction wheel reply has invalid crc;164;SUS_HANDLER;mission/acs/RwHandler.h
-0x5801;PLSPVhLP_NoPacketFound;No description;1;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x58a5;SUSS_ValueNotRead;No description;165;SUS_HANDLER;mission/acs/RwHandler.h
-0x5802;PLSPVhLP_DecodeBufTooSmall;No description;2;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x59a0;IPCI_PapbBusy;No description;160;CCSDS_IP_CORE_BRIDGE;linux/ipcore/PapbVcInterface.h
-0x5803;PLSPVhLP_PossiblePacketLossConsecutiveStart;No description;3;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x5aa0;PTME_UnknownVcId;No description;160;PTME;linux/ipcore/Ptme.h
-0x5804;PLSPVhLP_PossiblePacketLossConsecutiveEnd;No description;4;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x5c01;STRHLP_SdNotMounted;SD card specified in path string not mounted;1;STR_HELPER;linux/acs/StrComHandler.h
-0x5805;PLSPVhLP_HdlcError;No description;5;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x5c02;STRHLP_FileNotExists;Specified file does not exist on filesystem;2;STR_HELPER;linux/acs/StrComHandler.h
-0x58a0;PLSPVhLP_FileClosedAccidentally;File accidentally close;160;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x5c03;STRHLP_PathNotExists;Specified path does not exist;3;STR_HELPER;linux/acs/StrComHandler.h
-0x58a1;PLSPVhLP_ProcessTerminated;Process has been terminated by command;161;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x5c04;STRHLP_FileCreationFailed;Failed to create download image or read flash file;4;STR_HELPER;linux/acs/StrComHandler.h
-0x58a2;PLSPVhLP_PathNotExists;Received command with invalid pathname;162;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x5c05;STRHLP_RegionMismatch;Region in flash write/read reply does not match expected region;5;STR_HELPER;linux/acs/StrComHandler.h
-0x58a3;PLSPVhLP_EventBufferReplyInvalidApid;Expected event buffer TM but received space packet with other APID;163;PLOC_SUPV_HELPER;linux/payload/PlocSupvUartMan.h
+0x5c06;STRHLP_AddressMismatch;Address in flash write/read reply does not match expected address;6;STR_HELPER;linux/acs/StrComHandler.h
-0x59a0;SUSS_ErrorUnlockMutex;No description;160;SUS_HANDLER;mission/acs/archive/LegacySusHandler.h
+0x5c07;STRHLP_LengthMismatch;Length in flash write/read reply does not match expected length;7;STR_HELPER;linux/acs/StrComHandler.h
-0x59a1;SUSS_ErrorLockMutex;No description;161;SUS_HANDLER;mission/acs/archive/LegacySusHandler.h
+0x5c08;STRHLP_StatusError;Status field in reply signals error;8;STR_HELPER;linux/acs/StrComHandler.h
-0x5aa0;IPCI_PapbBusy;No description;160;CCSDS_IP_CORE_BRIDGE;linux/ipcore/PapbVcInterface.h
+0x5c09;STRHLP_InvalidTypeId;Reply has invalid type ID (should be of action reply type);9;STR_HELPER;linux/acs/StrComHandler.h
-0x5ba0;PTME_UnknownVcId;No description;160;PTME;linux/ipcore/Ptme.h
+0x5c0a;STRHLP_ReceptionTimeout;No description;10;STR_HELPER;linux/acs/StrComHandler.h
-0x5d01;STRHLP_SdNotMounted;SD card specified in path string not mounted;1;STR_HELPER;linux/acs/StrComHandler.h
+0x5c0b;STRHLP_DecodingError;No description;11;STR_HELPER;linux/acs/StrComHandler.h
-0x5d02;STRHLP_FileNotExists;Specified file does not exist on filesystem;2;STR_HELPER;linux/acs/StrComHandler.h
+0x5d00;GOMS_PacketTooLong;No description;0;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d03;STRHLP_PathNotExists;Specified path does not exist;3;STR_HELPER;linux/acs/StrComHandler.h
+0x5d01;GOMS_InvalidTableId;No description;1;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d04;STRHLP_FileCreationFailed;Failed to create download image or read flash file;4;STR_HELPER;linux/acs/StrComHandler.h
+0x5d02;GOMS_InvalidAddress;No description;2;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d05;STRHLP_RegionMismatch;Region in flash write/read reply does not match expected region;5;STR_HELPER;linux/acs/StrComHandler.h
+0x5d03;GOMS_InvalidParamSize;No description;3;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d06;STRHLP_AddressMismatch;Address in flash write/read reply does not match expected address;6;STR_HELPER;linux/acs/StrComHandler.h
+0x5d04;GOMS_InvalidPayloadSize;No description;4;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d07;STRHLP_LengthMismatch;Length in flash write/read reply does not match expected length;7;STR_HELPER;linux/acs/StrComHandler.h
+0x5d05;GOMS_UnknownReplyId;No description;5;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
-0x5d08;STRHLP_StatusError;Status field in reply signals error;8;STR_HELPER;linux/acs/StrComHandler.h
+0x5ea0;PLMEMDUMP_MramAddressTooHigh;The capacity of the MRAM amounts to 512 kB. Thus the maximum address must not be higher than 0x7d000.;160;PLOC_MEMORY_DUMPER;linux/payload/PlocMemoryDumper.h
-0x5d09;STRHLP_InvalidTypeId;Reply has invalid type ID (should be of action reply type);9;STR_HELPER;linux/acs/StrComHandler.h
+0x5ea1;PLMEMDUMP_MramInvalidAddressCombination;The specified end address is lower than the start address;161;PLOC_MEMORY_DUMPER;linux/payload/PlocMemoryDumper.h
-0x5d0a;STRHLP_ReceptionTimeout;No description;10;STR_HELPER;linux/acs/StrComHandler.h
+0x5fa0;PDEC_AbandonedCltuRetval;No description;160;PDEC_HANDLER;linux/ipcore/pdec.h
-0x5d0b;STRHLP_DecodingError;No description;11;STR_HELPER;linux/acs/StrComHandler.h
+0x5fa1;PDEC_FrameDirtyRetval;No description;161;PDEC_HANDLER;linux/ipcore/pdec.h
-0x5e00;GOMS_PacketTooLong;No description;0;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5fa2;PDEC_FrameIllegalMultipleReasons;No description;162;PDEC_HANDLER;linux/ipcore/pdec.h
-0x5e01;GOMS_InvalidTableId;No description;1;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5fa3;PDEC_AdDiscardedLockoutRetval;No description;163;PDEC_HANDLER;linux/ipcore/pdec.h
-0x5e02;GOMS_InvalidAddress;No description;2;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5fa4;PDEC_AdDiscardedWaitRetval;No description;164;PDEC_HANDLER;linux/ipcore/pdec.h
-0x5e03;GOMS_InvalidParamSize;No description;3;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5fa5;PDEC_AdDiscardedNsVs;No description;165;PDEC_HANDLER;linux/ipcore/pdec.h
-0x5e04;GOMS_InvalidPayloadSize;No description;4;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5fa6;PDEC_NoReportRetval;No description;166;PDEC_HANDLER;linux/ipcore/pdec.h
-0x5e05;GOMS_UnknownReplyId;No description;5;GOM_SPACE_HANDLER;mission/power/GomspaceDeviceHandler.h
+0x5fa7;PDEC_ErrorVersionNumberRetval;No description;167;PDEC_HANDLER;linux/ipcore/pdec.h
-0x5fa0;PLMEMDUMP_MramAddressTooHigh;The capacity of the MRAM amounts to 512 kB. Thus the maximum address must not be higher than 0x7d000.;160;PLOC_MEMORY_DUMPER;linux/payload/PlocMemoryDumper.h
+0x5fa8;PDEC_IllegalCombinationRetval;No description;168;PDEC_HANDLER;linux/ipcore/pdec.h
-0x5fa1;PLMEMDUMP_MramInvalidAddressCombination;The specified end address is lower than the start address;161;PLOC_MEMORY_DUMPER;linux/payload/PlocMemoryDumper.h
+0x5fa9;PDEC_InvalidScIdRetval;No description;169;PDEC_HANDLER;linux/ipcore/pdec.h
-0x60a0;PDEC_AbandonedCltuRetval;No description;160;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5faa;PDEC_InvalidVcIdMsbRetval;No description;170;PDEC_HANDLER;linux/ipcore/pdec.h
-0x60a1;PDEC_FrameDirtyRetval;No description;161;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fab;PDEC_InvalidVcIdLsbRetval;No description;171;PDEC_HANDLER;linux/ipcore/pdec.h
-0x60a2;PDEC_FrameIllegalMultipleReasons;No description;162;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fac;PDEC_NsNotZeroRetval;No description;172;PDEC_HANDLER;linux/ipcore/pdec.h
-0x60a3;PDEC_AdDiscardedLockoutRetval;No description;163;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fae;PDEC_InvalidBcCc;No description;174;PDEC_HANDLER;linux/ipcore/pdec.h
-0x60a4;PDEC_AdDiscardedWaitRetval;No description;164;PDEC_HANDLER;linux/ipcore/pdec.h
+0x5fb0;PDEC_CommandNotImplemented;Received action message with unknown action id;176;PDEC_HANDLER;linux/ipcore/pdec.h
-0x60a5;PDEC_AdDiscardedNsVs;No description;165;PDEC_HANDLER;linux/ipcore/pdec.h
+0x60a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/com/CcsdsIpCoreHandler.h
-0x60a6;PDEC_NoReportRetval;No description;166;PDEC_HANDLER;linux/ipcore/pdec.h
+0x61a0;RS_RateNotSupported;The commanded rate is not supported by the current FPGA design;160;RATE_SETTER;linux/ipcore/PtmeConfig.h
-0x60a7;PDEC_ErrorVersionNumberRetval;No description;167;PDEC_HANDLER;linux/ipcore/pdec.h
+0x61a1;RS_BadBitRate;Bad bitrate has been commanded (e.g. 0);161;RATE_SETTER;linux/ipcore/PtmeConfig.h
-0x60a8;PDEC_IllegalCombinationRetval;No description;168;PDEC_HANDLER;linux/ipcore/pdec.h
+0x61a2;RS_ClkInversionFailed;Failed to invert clock and thus change the time the data is updated with respect to the tx clock;162;RATE_SETTER;linux/ipcore/PtmeConfig.h
-0x60a9;PDEC_InvalidScIdRetval;No description;169;PDEC_HANDLER;linux/ipcore/pdec.h
+0x61a3;RS_TxManipulatorConfigFailed;Failed to change configuration bit of tx clock manipulator;163;RATE_SETTER;linux/ipcore/PtmeConfig.h
-0x60aa;PDEC_InvalidVcIdMsbRetval;No description;170;PDEC_HANDLER;linux/ipcore/pdec.h
+0x6201;JSONBASE_JsonFileNotExists;Specified json file does not exist;1;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
-0x60ab;PDEC_InvalidVcIdLsbRetval;No description;171;PDEC_HANDLER;linux/ipcore/pdec.h
+0x6202;JSONBASE_SetNotExists;Requested set does not exist in json file;2;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
-0x60ac;PDEC_NsNotZeroRetval;No description;172;PDEC_HANDLER;linux/ipcore/pdec.h
+0x6203;JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
-0x60ae;PDEC_InvalidBcCc;No description;174;PDEC_HANDLER;linux/ipcore/pdec.h
+0x63a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NvmParameterBase.h
-0x60b0;PDEC_CommandNotImplemented;Received action message with unknown action id;176;PDEC_HANDLER;linux/ipcore/pdec.h
+0x64a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;160;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
-0x61a0;CCSDS_CommandNotImplemented;Received action message with unknown action id;160;CCSDS_HANDLER;mission/com/CcsdsIpCoreHandler.h
+0x64a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;161;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
-0x62a0;RS_RateNotSupported;The commanded rate is not supported by the current FPGA design;160;RATE_SETTER;linux/ipcore/PtmeConfig.h
+0x65a0;PLMPHLP_FileWriteError;File error occured for file transfers from OBC to the MPSoC.;160;PLOC_MPSOC_HELPER;linux/payload/PlocMpsocSpecialComHelper.h
-0x62a1;RS_BadBitRate;Bad bitrate has been commanded (e.g. 0);161;RATE_SETTER;linux/ipcore/PtmeConfig.h
+0x65a1;PLMPHLP_FileReadError;File error occured for file transfers from MPSoC to OBC.;161;PLOC_MPSOC_HELPER;linux/payload/PlocMpsocSpecialComHelper.h
-0x62a2;RS_ClkInversionFailed;Failed to invert clock and thus change the time the data is updated with respect to the tx clock;162;RATE_SETTER;linux/ipcore/PtmeConfig.h
+0x66a0;SADPL_CommandNotSupported;No description;160;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x62a3;RS_TxManipulatorConfigFailed;Failed to change configuration bit of tx clock manipulator;163;RATE_SETTER;linux/ipcore/PtmeConfig.h
+0x66a1;SADPL_DeploymentAlreadyExecuting;No description;161;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x6301;JSONBASE_JsonFileNotExists;Specified json file does not exist;1;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
+0x66a2;SADPL_MainSwitchTimeoutFailure;No description;162;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x6302;JSONBASE_SetNotExists;Requested set does not exist in json file;2;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
+0x66a3;SADPL_SwitchingDeplSa1Failed;No description;163;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x6303;JSONBASE_ParamNotExists;Requested parameter does not exist in json file;3;ARCSEC_JSON_BASE;mission/acs/str/ArcsecJsonParamBase.h
+0x66a4;SADPL_SwitchingDeplSa2Failed;No description;164;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
-0x64a0;NVMB_KeyNotExists;Specified key does not exist in json file;160;NVM_PARAM_BASE;mission/memory/NvmParameterBase.h
+0x67a0;MPSOCRTVIF_CrcFailure;Space Packet received from PLOC has invalid CRC;160;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x65a0;FSHLP_SdNotMounted;SD card specified with path string not mounted;160;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
+0x67a1;MPSOCRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC;161;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x65a1;FSHLP_FileNotExists;Specified file does not exist on filesystem;161;FILE_SYSTEM_HELPER;bsp_q7s/fs/FilesystemHelper.h
+0x67a2;MPSOCRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC;162;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x66a0;PLMPHLP_FileWriteError;File error occured for file transfers from OBC to the MPSoC.;160;PLOC_MPSOC_HELPER;linux/payload/PlocMpsocSpecialComHelper.h
+0x67a3;MPSOCRTVIF_InvalidApid;Received space packet with invalid APID from PLOC;163;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x66a1;PLMPHLP_FileReadError;File error occured for file transfers from MPSoC to OBC.;161;PLOC_MPSOC_HELPER;linux/payload/PlocMpsocSpecialComHelper.h
+0x67a4;MPSOCRTVIF_InvalidLength;Received command with invalid length;164;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a0;SADPL_CommandNotSupported;No description;160;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x67a5;MPSOCRTVIF_FilenameTooLong;Filename of file in OBC filesystem is too long;165;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a1;SADPL_DeploymentAlreadyExecuting;No description;161;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x67a6;MPSOCRTVIF_MpsocHelperExecuting;MPSoC helper is currently executing a command;166;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a2;SADPL_MainSwitchTimeoutFailure;No description;162;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x67a7;MPSOCRTVIF_MpsocFilenameTooLong;Filename of MPSoC file is to long (max. 256 bytes);167;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a3;SADPL_SwitchingDeplSa1Failed;No description;163;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x67a8;MPSOCRTVIF_InvalidParameter;Command has invalid parameter;168;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x67a4;SADPL_SwitchingDeplSa2Failed;No description;164;SA_DEPL_HANDLER;mission/SolarArrayDeploymentHandler.h
+0x67a9;MPSOCRTVIF_NameTooLong;Received command has file string with invalid length;169;MPSOC_RETURN_VALUES_IF;linux/payload/mpsocRetvals.h
-0x6810;MPSOCRTVIF_CommandTimeout;Command has timed out.;16;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a0;SPVRTVIF_CrcFailure;Space Packet received from PLOC supervisor has invalid CRC;160;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a0;MPSOCRTVIF_CrcFailure;Space Packet received from PLOC has invalid CRC;160;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a1;SPVRTVIF_InvalidServiceId;No description;161;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a1;MPSOCRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC;161;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a2;SPVRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC supervisor;162;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a2;MPSOCRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC;162;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a3;SPVRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC supervisor;163;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a3;MPSOCRTVIF_InvalidApid;Received space packet with invalid APID from PLOC;163;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a4;SPVRTVIF_InvalidApid;Received space packet with invalid APID from PLOC supervisor;164;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a4;MPSOCRTVIF_InvalidLength;Received command with invalid length;164;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a5;SPVRTVIF_GetTimeFailure;Failed to read current system time;165;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a5;MPSOCRTVIF_FilenameTooLong;Filename of file in OBC filesystem is too long;165;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a6;SPVRTVIF_InvalidWatchdog;Received command with invalid watchdog parameter. Valid watchdogs are 0 for PS, 1 for PL and 2 for INT;166;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a6;MPSOCRTVIF_MpsocHelperExecuting;MPSoC helper is currently executing a command;166;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a7;SPVRTVIF_InvalidWatchdogTimeout;Received watchdog timeout config command with invalid timeout. Valid timeouts must be in the range between 1000 and 360000 ms.;167;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a7;MPSOCRTVIF_MpsocFilenameTooLong;Filename of MPSoC file is to long (max. 256 bytes);167;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a8;SPVRTVIF_InvalidLatchupId;Received latchup config command with invalid latchup ID;168;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a8;MPSOCRTVIF_InvalidParameter;Command has invalid parameter;168;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68a9;SPVRTVIF_SweepPeriodTooSmall;Received set adc sweep period command with invalid sweep period. Must be larger than 21.;169;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x68a9;MPSOCRTVIF_NameTooLong;Received command has file string with invalid length;169;MPSOC_RETURN_VALUES_IF;linux/payload/plocMpsocHelpers.h
+0x68aa;SPVRTVIF_InvalidTestParam;Receive auto EM test command with invalid test param. Valid params are 1 and 2.;170;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69a0;SPVRTVIF_CrcFailure;Space Packet received from PLOC supervisor has invalid CRC;160;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x68ab;SPVRTVIF_MramPacketParsingFailure;Returned when scanning for MRAM dump packets failed.;171;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69a1;SPVRTVIF_InvalidServiceId;No description;161;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x68ac;SPVRTVIF_InvalidMramAddresses;Returned when the start and stop addresses of the MRAM dump or MRAM  wipe commands are invalid (e.g. start address bigger than stop address);172;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69a2;SPVRTVIF_ReceivedAckFailure;Received ACK failure reply from PLOC supervisor;162;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x68ad;SPVRTVIF_NoMramPacket;Expect reception of an MRAM dump packet but received space packet with other apid.;173;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69a3;SPVRTVIF_ReceivedExeFailure;Received execution failure reply from PLOC supervisor;163;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x68ae;SPVRTVIF_PathDoesNotExist;Path to PLOC directory on SD card does not exist;174;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69a4;SPVRTVIF_InvalidApid;Received space packet with invalid APID from PLOC supervisor;164;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x68af;SPVRTVIF_MramFileNotExists;MRAM dump file does not exists. The file should actually already have been created with the reception of the first dump packet.;175;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69a5;SPVRTVIF_GetTimeFailure;Failed to read current system time;165;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x68b0;SPVRTVIF_InvalidReplyLength;No description;176;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69a6;SPVRTVIF_InvalidWatchdog;Received command with invalid watchdog parameter. Valid watchdogs are 0 for PS, 1 for PL and 2 for INT;166;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x68b1;SPVRTVIF_InvalidLength;Received action command has invalid length;177;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69a7;SPVRTVIF_InvalidWatchdogTimeout;Received watchdog timeout config command with invalid timeout. Valid timeouts must be in the range between 1000 and 360000 ms.;167;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x68b2;SPVRTVIF_FilenameTooLong;Filename too long;178;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69a8;SPVRTVIF_InvalidLatchupId;Received latchup config command with invalid latchup ID;168;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x68b3;SPVRTVIF_UpdateStatusReportInvalidLength;Received update status report with invalid packet length field;179;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69a9;SPVRTVIF_SweepPeriodTooSmall;Received set adc sweep period command with invalid sweep period. Must be larger than 21.;169;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x68b4;SPVRTVIF_UpdateCrcFailure;Update status report does not contain expected CRC. There might be a bit flip in the update memory region.;180;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69aa;SPVRTVIF_InvalidTestParam;Receive auto EM test command with invalid test param. Valid params are 1 and 2.;170;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x68b5;SPVRTVIF_SupvHelperExecuting;Supervisor helper task ist currently executing a command (wait until helper tas has finished or interrupt by sending the terminate command);181;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69ab;SPVRTVIF_MramPacketParsingFailure;Returned when scanning for MRAM dump packets failed.;171;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x68c0;SPVRTVIF_BufTooSmall;No description;192;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69ac;SPVRTVIF_InvalidMramAddresses;Returned when the start and stop addresses of the MRAM dump or MRAM  wipe commands are invalid (e.g. start address bigger than stop address);172;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x68c1;SPVRTVIF_NoReplyTimeout;No description;193;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
-0x69ad;SPVRTVIF_NoMramPacket;Expect reception of an MRAM dump packet but received space packet with other apid.;173;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x6900;ACSCTRL_FileDeletionFailed;File deletion failed and at least one file is still existent.;0;ACS_CTRL;mission/controller/AcsController.h
-0x69ae;SPVRTVIF_PathDoesNotExist;Path to PLOC directory on SD card does not exist;174;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x6a02;ACSMEKF_MekfUninitialized;No description;2;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x69af;SPVRTVIF_MramFileNotExists;MRAM dump file does not exists. The file should actually already have been created with the reception of the first dump packet.;175;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x6a03;ACSMEKF_MekfNoGyrData;No description;3;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x69b0;SPVRTVIF_InvalidReplyLength;No description;176;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x6a04;ACSMEKF_MekfNoModelVectors;No description;4;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x69b1;SPVRTVIF_InvalidLength;Received action command has invalid length;177;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x6a05;ACSMEKF_MekfNoSusMgmStrData;No description;5;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x69b2;SPVRTVIF_FilenameTooLong;Filename too long;178;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x6a06;ACSMEKF_MekfCovarianceInversionFailed;No description;6;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x69b3;SPVRTVIF_UpdateStatusReportInvalidLength;Received update status report with invalid packet length field;179;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x6a07;ACSMEKF_MekfNotFinite;No description;7;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x69b4;SPVRTVIF_UpdateCrcFailure;Update status report does not contain expected CRC. There might be a bit flip in the update memory region.;180;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x6a08;ACSMEKF_MekfInitialized;No description;8;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x69b5;SPVRTVIF_SupvHelperExecuting;Supervisor helper task ist currently executing a command (wait until helper tas has finished or interrupt by sending the terminate command);181;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x6a09;ACSMEKF_MekfRunning;No description;9;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
-0x69c0;SPVRTVIF_BufTooSmall;No description;192;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x6b00;SDMA_OpOngoing;No description;0;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x69c1;SPVRTVIF_NoReplyTimeout;No description;193;SUPV_RETURN_VALUES_IF;linux/payload/plocSupvDefs.h
+0x6b01;SDMA_AlreadyOn;No description;1;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6aa0;ACSCTRL_FileDeletionFailed;File deletion failed and at least one file is still existent.;160;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6b02;SDMA_AlreadyMounted;No description;2;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6aa1;ACSCTRL_WriteFileFailed;Writing the TLE to the file has failed.;161;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6b03;SDMA_AlreadyOff;No description;3;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6aa2;ACSCTRL_ReadFileFailed;Reading the TLE to the file has failed.;162;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6b0a;SDMA_StatusFileNexists;No description;10;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6aa3;ACSCTRL_SingleRwUnavailable;A single RW has failed.;163;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6b0b;SDMA_StatusFileFormatInvalid;No description;11;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6aa4;ACSCTRL_MultipleRwUnavailable;Multiple RWs have failed.;164;ACS_CTRL;mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+0x6b0c;SDMA_MountError;No description;12;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6b02;ACSMEKF_MekfUninitialized;No description;2;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b0d;SDMA_UnmountError;No description;13;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6b03;ACSMEKF_MekfNoGyrData;No description;3;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b0e;SDMA_SystemCallError;No description;14;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6b04;ACSMEKF_MekfNoModelVectors;No description;4;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6b0f;SDMA_PopenCallError;No description;15;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
-0x6b05;ACSMEKF_MekfNoSusMgmStrData;No description;5;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6c00;LPH_SdNotReady;No description;0;LOCAL_PARAM_HANDLER;bsp_q7s/memory/LocalParameterHandler.h
-0x6b06;ACSMEKF_MekfCovarianceInversionFailed;No description;6;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6d00;PTM_DumpDone;No description;0;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
-0x6b07;ACSMEKF_MekfNotFinite;No description;7;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6d01;PTM_BusyDumping;No description;1;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
-0x6b08;ACSMEKF_MekfInitialized;No description;8;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x6e00;TMS_IsBusy;No description;0;TM_SINK;mission/tmtc/DirectTmSinkIF.h
-0x6b09;ACSMEKF_MekfRunning;No description;9;ACS_MEKF;mission/controller/acs/MultiplicativeKalmanFilter.h
+0x7000;SCBU_KeyNotFound;No description;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h
 0x6c00;SDMA_OpOngoing;No description;0;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6c01;SDMA_AlreadyOn;No description;1;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6c02;SDMA_AlreadyMounted;No description;2;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6c03;SDMA_AlreadyOff;No description;3;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6c0a;SDMA_StatusFileNexists;No description;10;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6c0b;SDMA_StatusFileFormatInvalid;No description;11;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6c0c;SDMA_MountError;No description;12;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6c0d;SDMA_UnmountError;No description;13;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6c0e;SDMA_SystemCallError;No description;14;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6c0f;SDMA_PopenCallError;No description;15;SD_CARD_MANAGER;bsp_q7s/fs/SdCardManager.h
 0x6d00;LPH_SdNotReady;No description;0;LOCAL_PARAM_HANDLER;bsp_q7s/memory/LocalParameterHandler.h
 0x6e00;PTM_DumpDone;No description;0;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
 0x6e01;PTM_BusyDumping;No description;1;PERSISTENT_TM_STORE;mission/tmtc/PersistentTmStore.h
 0x6f00;TMS_IsBusy;No description;0;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x6f01;TMS_PartiallyWritten;No description;1;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x6f02;TMS_NoWriteActive;No description;2;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x6f03;TMS_Timeout;No description;3;TM_SINK;mission/tmtc/DirectTmSinkIF.h
 0x7000;VCS_ChannelDoesNotExist;No description;0;VIRTUAL_CHANNEL;mission/com/VirtualChannel.h
 0x7100;PLMPCOM_PacketReceived;No description;0;PLOC_MPSOC_COM;linux/payload/MpsocCommunication.h
 0x7101;PLMPCOM_FaultyPacketSize;No description;1;PLOC_MPSOC_COM;linux/payload/MpsocCommunication.h
 0x7102;PLMPCOM_CrcCheckFailed;No description;2;PLOC_MPSOC_COM;linux/payload/MpsocCommunication.h
 0x7300;SCBU_KeyNotFound;No description;0;SCRATCH_BUFFER;bsp_q7s/memory/scratchApi.h
--- a/generators/bsp_q7s_subsystems.csv
+++ b/generators/bsp_q7s_subsystems.csv
@ -60,5 +60,3 @@
 142;COM_SUBSYSTEM
 143;PERSISTENT_TM_STORE
 144;SYRLINKS_COM
 145;SUS_HANDLER
 146;CFDP_APP
--- a/generators/events/translateEvents.cpp
+++ b/generators/events/translateEvents.cpp
@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 325 translations.
+ * @brief    Auto-generated event translation file. Contains 304 translations.
 * @details
- * Generated on: 2024-05-06 13:47:38
+ * Generated on: 2023-08-21 15:54:29
 */
 #include "translateEvents.h"
@ -82,11 +82,8 @@ const char *BIT_LOCK_STRING = "BIT_LOCK";
 const char *BIT_LOCK_LOST_STRING = "BIT_LOCK_LOST";
 const char *FRAME_PROCESSING_FAILED_STRING = "FRAME_PROCESSING_FAILED";
 const char *CLOCK_SET_STRING = "CLOCK_SET";
 const char *CLOCK_DUMP_LEGACY_STRING = "CLOCK_DUMP_LEGACY";
 const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
 const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
-const char *CLOCK_DUMP_BEFORE_SETTING_TIME_STRING = "CLOCK_DUMP_BEFORE_SETTING_TIME";
+const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
 const char *CLOCK_DUMP_AFTER_SETTING_TIME_STRING = "CLOCK_DUMP_AFTER_SETTING_TIME";
 const char *TC_DELETION_FAILED_STRING = "TC_DELETION_FAILED";
 const char *TEST_STRING = "TEST";
 const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
@ -95,28 +92,19 @@ const char *MSG_QUEUE_ERROR_STRING = "MSG_QUEUE_ERROR";
 const char *SERIALIZATION_ERROR_STRING = "SERIALIZATION_ERROR";
 const char *FILESTORE_ERROR_STRING = "FILESTORE_ERROR";
 const char *FILENAME_TOO_LARGE_ERROR_STRING = "FILENAME_TOO_LARGE_ERROR";
 const char *HANDLING_CFDP_REQUEST_FAILED_STRING = "HANDLING_CFDP_REQUEST_FAILED";
 const char *SAFE_RATE_VIOLATION_STRING = "SAFE_RATE_VIOLATION";
-const char *RATE_RECOVERY_STRING = "RATE_RECOVERY";
+const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
 const char *MULTIPLE_RW_INVALID_STRING = "MULTIPLE_RW_INVALID";
 const char *MEKF_INVALID_INFO_STRING = "MEKF_INVALID_INFO";
 const char *MEKF_RECOVERY_STRING = "MEKF_RECOVERY";
 const char *MEKF_AUTOMATIC_RESET_STRING = "MEKF_AUTOMATIC_RESET";
-const char *PTG_CTRL_NO_ATTITUDE_INFORMATION_STRING = "PTG_CTRL_NO_ATTITUDE_INFORMATION";
+const char *MEKF_INVALID_MODE_VIOLATION_STRING = "MEKF_INVALID_MODE_VIOLATION";
 const char *SAFE_MODE_CONTROLLER_FAILURE_STRING = "SAFE_MODE_CONTROLLER_FAILURE";
 const char *TLE_TOO_OLD_STRING = "TLE_TOO_OLD";
 const char *TLE_FILE_READ_FAILED_STRING = "TLE_FILE_READ_FAILED";
 const char *PTG_RATE_VIOLATION_STRING = "PTG_RATE_VIOLATION";
 const char *DETUMBLE_TRANSITION_FAILED_STRING = "DETUMBLE_TRANSITION_FAILED";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
 const char *FDIR_REACTION_IGNORED_STRING = "FDIR_REACTION_IGNORED";
 const char *DATASET_READ_FAILED_STRING = "DATASET_READ_FAILED";
 const char *VOLTAGE_OUT_OF_BOUNDS_STRING = "VOLTAGE_OUT_OF_BOUNDS";
 const char *TIMEDELTA_OUT_OF_BOUNDS_STRING = "TIMEDELTA_OUT_OF_BOUNDS";
 const char *POWER_LEVEL_LOW_STRING = "POWER_LEVEL_LOW";
 const char *POWER_LEVEL_CRITICAL_STRING = "POWER_LEVEL_CRITICAL";
 const char *GPIO_PULL_HIGH_FAILED_STRING = "GPIO_PULL_HIGH_FAILED";
 const char *GPIO_PULL_LOW_FAILED_STRING = "GPIO_PULL_LOW_FAILED";
 const char *HEATER_WENT_ON_STRING = "HEATER_WENT_ON";
@ -140,9 +128,6 @@ const char *EXE_FAILURE_STRING = "EXE_FAILURE";
 const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE";
 const char *MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH";
 const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
 const char *SUPV_NOT_ON_STRING = "SUPV_NOT_ON";
 const char *SUPV_REPLY_TIMEOUT_STRING = "SUPV_REPLY_TIMEOUT";
 const char *CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE_STRING = "CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@ -164,8 +149,6 @@ const char *SUPV_EXE_FAILURE_STRING = "SUPV_EXE_FAILURE";
 const char *SUPV_CRC_FAILURE_EVENT_STRING = "SUPV_CRC_FAILURE_EVENT";
 const char *SUPV_HELPER_EXECUTING_STRING = "SUPV_HELPER_EXECUTING";
 const char *SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING = "SUPV_MPSOC_SHUTDOWN_BUILD_FAILED";
 const char *SUPV_ACK_UNKNOWN_COMMAND_STRING = "SUPV_ACK_UNKNOWN_COMMAND";
 const char *SUPV_EXE_ACK_UNKNOWN_COMMAND_STRING = "SUPV_EXE_ACK_UNKNOWN_COMMAND";
 const char *SANITIZATION_FAILED_STRING = "SANITIZATION_FAILED";
 const char *MOUNTED_SD_CARD_STRING = "MOUNTED_SD_CARD";
 const char *SEND_MRAM_DUMP_FAILED_STRING = "SEND_MRAM_DUMP_FAILED";
@ -245,7 +228,6 @@ const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903_STRING = "SIDE_SWITCH_TRANS
 const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
 const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
 const char *CANT_GET_FIX_STRING = "CANT_GET_FIX";
 const char *RESET_FAIL_STRING = "RESET_FAIL";
 const char *P60_BOOT_COUNT_STRING = "P60_BOOT_COUNT";
 const char *BATT_MODE_STRING = "BATT_MODE";
 const char *BATT_MODE_CHANGED_STRING = "BATT_MODE_CHANGED";
@ -327,9 +309,6 @@ const char *DUMP_NOK_CANCELLED_STRING = "DUMP_NOK_CANCELLED";
 const char *DUMP_MISC_CANCELLED_STRING = "DUMP_MISC_CANCELLED";
 const char *DUMP_HK_CANCELLED_STRING = "DUMP_HK_CANCELLED";
 const char *DUMP_CFDP_CANCELLED_STRING = "DUMP_CFDP_CANCELLED";
 const char *TEMPERATURE_ALL_ONES_START_STRING = "TEMPERATURE_ALL_ONES_START";
 const char *TEMPERATURE_ALL_ONES_RECOVERY_STRING = "TEMPERATURE_ALL_ONES_RECOVERY";
 const char *FAULT_HANDLER_TRIGGERED_STRING = "FAULT_HANDLER_TRIGGERED";
 const char *translateEvents(Event event) {
  switch ((event & 0xFFFF)) {
@ -488,15 +467,9 @@ const char *translateEvents(Event event) {
    case (8900):
      return CLOCK_SET_STRING;
    case (8901):
-      return CLOCK_DUMP_LEGACY_STRING;
+      return CLOCK_DUMP_STRING;
    case (8902):
      return CLOCK_SET_FAILURE_STRING;
    case (8903):
      return CLOCK_DUMP_STRING;
    case (8904):
      return CLOCK_DUMP_BEFORE_SETTING_TIME_STRING;
    case (8905):
      return CLOCK_DUMP_AFTER_SETTING_TIME_STRING;
    case (9100):
      return TC_DELETION_FAILED_STRING;
    case (9700):
@ -513,12 +486,10 @@ const char *translateEvents(Event event) {
      return FILESTORE_ERROR_STRING;
    case (10804):
      return FILENAME_TOO_LARGE_ERROR_STRING;
    case (10805):
      return HANDLING_CFDP_REQUEST_FAILED_STRING;
    case (11200):
      return SAFE_RATE_VIOLATION_STRING;
    case (11201):
-      return RATE_RECOVERY_STRING;
+      return SAFE_RATE_RECOVERY_STRING;
    case (11202):
      return MULTIPLE_RW_INVALID_STRING;
    case (11203):
@ -528,17 +499,11 @@ const char *translateEvents(Event event) {
    case (11205):
      return MEKF_AUTOMATIC_RESET_STRING;
    case (11206):
-      return PTG_CTRL_NO_ATTITUDE_INFORMATION_STRING;
+      return MEKF_INVALID_MODE_VIOLATION_STRING;
    case (11207):
      return SAFE_MODE_CONTROLLER_FAILURE_STRING;
    case (11208):
      return TLE_TOO_OLD_STRING;
    case (11209):
      return TLE_FILE_READ_FAILED_STRING;
    case (11210):
      return PTG_RATE_VIOLATION_STRING;
    case (11211):
      return DETUMBLE_TRANSITION_FAILED_STRING;
    case (11300):
      return SWITCH_CMD_SENT_STRING;
    case (11301):
@ -547,16 +512,6 @@ const char *translateEvents(Event event) {
      return SWITCHING_Q7S_DENIED_STRING;
    case (11303):
      return FDIR_REACTION_IGNORED_STRING;
    case (11304):
      return DATASET_READ_FAILED_STRING;
    case (11305):
      return VOLTAGE_OUT_OF_BOUNDS_STRING;
    case (11306):
      return TIMEDELTA_OUT_OF_BOUNDS_STRING;
    case (11307):
      return POWER_LEVEL_LOW_STRING;
    case (11308):
      return POWER_LEVEL_CRITICAL_STRING;
    case (11400):
      return GPIO_PULL_HIGH_FAILED_STRING;
    case (11401):
@ -603,12 +558,6 @@ const char *translateEvents(Event event) {
      return MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING;
    case (11606):
      return MPSOC_SHUTDOWN_FAILED_STRING;
    case (11607):
      return SUPV_NOT_ON_STRING;
    case (11608):
      return SUPV_REPLY_TIMEOUT_STRING;
    case (11609):
      return CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE_STRING;
    case (11701):
      return SELF_TEST_I2C_FAILURE_STRING;
    case (11702):
@ -651,10 +600,6 @@ const char *translateEvents(Event event) {
      return SUPV_HELPER_EXECUTING_STRING;
    case (12008):
      return SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING;
    case (12009):
      return SUPV_ACK_UNKNOWN_COMMAND_STRING;
    case (12010):
      return SUPV_EXE_ACK_UNKNOWN_COMMAND_STRING;
    case (12100):
      return SANITIZATION_FAILED_STRING;
    case (12101):
@ -813,8 +758,6 @@ const char *translateEvents(Event event) {
      return GPS_FIX_CHANGE_STRING;
    case (13101):
      return CANT_GET_FIX_STRING;
    case (13102):
      return RESET_FAIL_STRING;
    case (13200):
      return P60_BOOT_COUNT_STRING;
    case (13201):
@ -977,12 +920,6 @@ const char *translateEvents(Event event) {
      return DUMP_HK_CANCELLED_STRING;
    case (14314):
      return DUMP_CFDP_CANCELLED_STRING;
    case (14500):
      return TEMPERATURE_ALL_ONES_START_STRING;
    case (14501):
      return TEMPERATURE_ALL_ONES_RECOVERY_STRING;
    case (14600):
      return FAULT_HANDLER_TRIGGERED_STRING;
    default:
      return "UNKNOWN_EVENT";
  }
--- a/generators/objects/translateObjects.cpp
+++ b/generators/objects/translateObjects.cpp
@ -1,17 +1,15 @@
 /**
 * @brief  Auto-generated object translation file.
 * @details
- * Contains 180 translations.
+ * Contains 175 translations.
- * Generated on: 2024-05-06 13:47:38
+ * Generated on: 2023-08-21 15:54:29
 */
 #include "translateObjects.h"
 const char *P60DOCK_TEST_TASK_STRING = "P60DOCK_TEST_TASK";
 const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
 const char *CORE_CONTROLLER_STRING = "CORE_CONTROLLER";
 const char *POWER_CONTROLLER_STRING = "POWER_CONTROLLER";
 const char *GLOBAL_JSON_CFG_STRING = "GLOBAL_JSON_CFG";
 const char *XIPHOS_WDT_STRING = "XIPHOS_WDT";
 const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *MGM_0_LIS3_HANDLER_STRING = "MGM_0_LIS3_HANDLER";
 const char *GYRO_0_ADIS_HANDLER_STRING = "GYRO_0_ADIS_HANDLER";
@ -64,7 +62,6 @@ const char *PTME_VC3_CFDP_TM_STRING = "PTME_VC3_CFDP_TM";
 const char *PLOC_MPSOC_HANDLER_STRING = "PLOC_MPSOC_HANDLER";
 const char *PLOC_SUPERVISOR_HANDLER_STRING = "PLOC_SUPERVISOR_HANDLER";
 const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER";
 const char *PLOC_MPSOC_COMMUNICATION_STRING = "PLOC_MPSOC_COMMUNICATION";
 const char *SCEX_STRING = "SCEX";
 const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
 const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
@ -167,13 +164,11 @@ const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
 const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
 const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
 const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
 const char *CFDP_FAULT_HANDLER_STRING = "CFDP_FAULT_HANDLER";
 const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
 const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *TCS_SUBSYSTEM_STRING = "TCS_SUBSYSTEM";
 const char *COM_SUBSYSTEM_STRING = "COM_SUBSYSTEM";
 const char *EPS_SUBSYSTEM_STRING = "EPS_SUBSYSTEM";
 const char *MISC_TM_STORE_STRING = "MISC_TM_STORE";
 const char *OK_TM_STORE_STRING = "OK_TM_STORE";
 const char *NOT_OK_TM_STORE_STRING = "NOT_OK_TM_STORE";
@ -195,12 +190,8 @@ const char *translateObject(object_id_t object) {
      return ACS_CONTROLLER_STRING;
    case 0x43000003:
      return CORE_CONTROLLER_STRING;
    case 0x43000004:
      return POWER_CONTROLLER_STRING;
    case 0x43000006:
      return GLOBAL_JSON_CFG_STRING;
    case 0x43000007:
      return XIPHOS_WDT_STRING;
    case 0x43400001:
      return THERMAL_CONTROLLER_STRING;
    case 0x44120006:
@ -305,8 +296,6 @@ const char *translateObject(object_id_t object) {
      return PLOC_SUPERVISOR_HANDLER_STRING;
    case 0x44330017:
      return PLOC_SUPERVISOR_HELPER_STRING;
    case 0x44330018:
      return PLOC_MPSOC_COMMUNICATION_STRING;
    case 0x44330032:
      return SCEX_STRING;
    case 0x444100A2:
@ -511,8 +500,6 @@ const char *translateObject(object_id_t object) {
      return CFDP_HANDLER_STRING;
    case 0x73000206:
      return CFDP_DISTRIBUTOR_STRING;
    case 0x73000207:
      return CFDP_FAULT_HANDLER_STRING;
    case 0x73010000:
      return EIVE_SYSTEM_STRING;
    case 0x73010001:
@ -523,8 +510,6 @@ const char *translateObject(object_id_t object) {
      return TCS_SUBSYSTEM_STRING;
    case 0x73010004:
      return COM_SUBSYSTEM_STRING;
    case 0x73010005:
      return EPS_SUBSYSTEM_STRING;
    case 0x73020001:
      return MISC_TM_STORE_STRING;
    case 0x73020002:
--- a/linux/ObjectFactory.cpp
+++ b/linux/ObjectFactory.cpp
@ -13,7 +13,6 @@
 #include <linux/tcs/Max31865RtdPolling.h>
 #include <mission/acs/SusHandler.h>
 #include <mission/controller/AcsController.h>
 #include <mission/controller/PowerController.h>
 #include <mission/genericFactory.h>
 #include <mission/payload/ScexDeviceHandler.h>
 #include <mission/system/acs/SusAssembly.h>
@ -24,10 +23,13 @@
 #include "OBSWConfig.h"
 #include "devConf.h"
 #include "devices/addresses.h"
 #include "devices/gpioIds.h"
 #include "eive/definitions.h"
 #include "mission/system/acs/acsModeTree.h"
-#include "mission/system/payload/payloadModeTree.h"
+#include "mission/system/tcs/tcsModeTree.h"
-#include "mission/system/power/epsModeTree.h"
+#include "mission/system/tree/payloadModeTree.h"
 #include "mission/tcs/defs.h"
 void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF,
                                              PowerSwitchIF& pwrSwitcher, std::string spiDev,
@ -202,78 +204,74 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
  GpioCallback* gpioRtdIc0 = new GpioCallback("Chip select RTD IC0", Direction::OUT, Levels::HIGH,
                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_0, gpioRtdIc0);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_3, gpioRtdIc0);
  GpioCallback* gpioRtdIc1 = new GpioCallback("Chip select RTD IC1", Direction::OUT, Levels::HIGH,
                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_1, gpioRtdIc1);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_4, gpioRtdIc1);
  GpioCallback* gpioRtdIc2 = new GpioCallback("Chip select RTD IC2", Direction::OUT, Levels::HIGH,
                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_2, gpioRtdIc2);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_5, gpioRtdIc2);
  GpioCallback* gpioRtdIc3 = new GpioCallback("Chip select RTD IC3", Direction::OUT, Levels::HIGH,
                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_3, gpioRtdIc3);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_6, gpioRtdIc3);
  GpioCallback* gpioRtdIc4 = new GpioCallback("Chip select RTD IC4", Direction::OUT, Levels::HIGH,
                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_4, gpioRtdIc4);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_7, gpioRtdIc4);
  GpioCallback* gpioRtdIc5 = new GpioCallback("Chip select RTD IC5", Direction::OUT, Levels::HIGH,
                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_5, gpioRtdIc5);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_8, gpioRtdIc5);
  GpioCallback* gpioRtdIc6 = new GpioCallback("Chip select RTD IC6", Direction::OUT, Levels::HIGH,
                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_6, gpioRtdIc6);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_9, gpioRtdIc6);
  GpioCallback* gpioRtdIc7 = new GpioCallback("Chip select RTD IC7", Direction::OUT, Levels::HIGH,
                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_7, gpioRtdIc7);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_10, gpioRtdIc7);
  GpioCallback* gpioRtdIc8 = new GpioCallback("Chip select RTD IC8", Direction::OUT, Levels::HIGH,
                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_8, gpioRtdIc8);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_11, gpioRtdIc8);
  GpioCallback* gpioRtdIc9 = new GpioCallback("Chip select RTD IC9", Direction::OUT, Levels::HIGH,
                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_9, gpioRtdIc9);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_12, gpioRtdIc9);
  GpioCallback* gpioRtdIc10 = new GpioCallback("Chip select RTD IC10", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_10, gpioRtdIc10);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_13, gpioRtdIc10);
  GpioCallback* gpioRtdIc11 = new GpioCallback("Chip select RTD IC11", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_11, gpioRtdIc11);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_14, gpioRtdIc11);
  GpioCallback* gpioRtdIc12 = new GpioCallback("Chip select RTD IC12", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_12, gpioRtdIc12);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_15, gpioRtdIc12);
  GpioCallback* gpioRtdIc13 = new GpioCallback("Chip select RTD IC13", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_13, gpioRtdIc13);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_16, gpioRtdIc13);
  GpioCallback* gpioRtdIc14 = new GpioCallback("Chip select RTD IC14", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_14, gpioRtdIc14);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_17, gpioRtdIc14);
  GpioCallback* gpioRtdIc15 = new GpioCallback("Chip select RTD IC15", Direction::OUT, Levels::HIGH,
                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_15, gpioRtdIc15);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_18, gpioRtdIc15);
  gpioChecker(gpioComIF->addGpios(rtdGpioCookie), "RTDs");
 #if OBSW_ADD_RTD_DEVICES == 1
  using namespace EiveMax31855;
  // ! NOTE !
  // The chip selects for device 9 and 11 are swapped here. It is strongly suspected the cables
  // for those devices were swapped during integration. This is probably the easiest way to
  // fix the issue.
  std::array<std::pair<address_t, gpioId_t>, NUM_RTDS> cookieArgs = {{
      {addresses::RTD_IC_0, gpioIds::RTD_IC_0},
      {addresses::RTD_IC_1, gpioIds::RTD_IC_1},
      {addresses::RTD_IC_2, gpioIds::RTD_IC_2},
      {addresses::RTD_IC_3, gpioIds::RTD_IC_3},
      {addresses::RTD_IC_4, gpioIds::RTD_IC_4},
      {addresses::RTD_IC_5, gpioIds::RTD_IC_5},
      {addresses::RTD_IC_6, gpioIds::RTD_IC_6},
      {addresses::RTD_IC_7, gpioIds::RTD_IC_7},
      {addresses::RTD_IC_8, gpioIds::RTD_IC_8},
      {addresses::RTD_IC_11, gpioIds::RTD_IC_11},
      {addresses::RTD_IC_10, gpioIds::RTD_IC_10},
      {addresses::RTD_IC_9, gpioIds::RTD_IC_9},
      {addresses::RTD_IC_10, gpioIds::RTD_IC_10},
      {addresses::RTD_IC_11, gpioIds::RTD_IC_11},
      {addresses::RTD_IC_12, gpioIds::RTD_IC_12},
      {addresses::RTD_IC_13, gpioIds::RTD_IC_13},
      {addresses::RTD_IC_14, gpioIds::RTD_IC_14},
      {addresses::RTD_IC_15, gpioIds::RTD_IC_15},
      {addresses::RTD_IC_16, gpioIds::RTD_IC_16},
      {addresses::RTD_IC_17, gpioIds::RTD_IC_17},
      {addresses::RTD_IC_18, gpioIds::RTD_IC_18},
  }};
  // HSPD: Heatspreader
@ -331,23 +329,14 @@ void ObjectFactory::createScexComponents(std::string uartDev, PowerSwitchIF* pwr
  scexHandler->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
 }
-AcsController* ObjectFactory::createAcsController(bool connectSubsystem, bool enableHkSets,
+AcsController* ObjectFactory::createAcsController(bool connectSubsystem, bool enableHkSets) {
-                                                  SdCardMountedIF& mountedIF) {
+  auto acsCtrl = new AcsController(objects::ACS_CONTROLLER, enableHkSets);
  auto acsCtrl = new AcsController(objects::ACS_CONTROLLER, enableHkSets, mountedIF);
  if (connectSubsystem) {
    acsCtrl->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
  }
  return acsCtrl;
 }
 PowerController* ObjectFactory::createPowerController(bool connectSubsystem, bool enableHkSets) {
  auto pwrCtrl = new PowerController(objects::POWER_CONTROLLER, enableHkSets);
  if (connectSubsystem) {
    pwrCtrl->connectModeTreeParent(satsystem::eps::EPS_SUBSYSTEM);
  }
  return pwrCtrl;
 }
 void ObjectFactory::gpioChecker(ReturnValue_t result, std::string output) {
  if (result != returnvalue::OK) {
    sif::error << "ObjectFactory: Adding GPIOs failed for " << output << std::endl;
--- a/linux/ObjectFactory.h
+++ b/linux/ObjectFactory.h
@ -16,7 +16,6 @@ class GpioIF;
 class SpiComIF;
 class PowerSwitchIF;
 class AcsController;
 class PowerController;
 namespace ObjectFactory {
@ -31,8 +30,6 @@ void createScexComponents(std::string uartDev, PowerSwitchIF* pwrSwitcher,
 void gpioChecker(ReturnValue_t result, std::string output);
-AcsController* createAcsController(bool connectSubsystem, bool enableHkSets,
+AcsController* createAcsController(bool connectSubsystem, bool enableHkSets);
                                   SdCardMountedIF& mountedIF);
 PowerController* createPowerController(bool connectSubsystem, bool enableHkSets);
 }  // namespace ObjectFactory
--- a/linux/acs/AcsBoardPolling.cpp
+++ b/linux/acs/AcsBoardPolling.cpp
@ -767,9 +767,6 @@ void AcsBoardPolling::mgmRm3100Handler(MgmRm3100& mgm) {
        mgm.replyResult = result;
        return;
      }
      // For some reason, bit 1 is sometimes set on the reply, even if it is not set for the
      // command.. Ignore it for now by clearing it.
      rawReply[1] &= ~(1 << 1);
      if (rawReply[1] != mgmRm3100::CMM_VALUE) {
        sif::error << "AcsBoardPolling: MGM RM3100 read back CMM invalid" << std::endl;
        mgm.replyResult = result;
--- a/linux/acs/GpsHyperionLinuxController.cpp
+++ b/linux/acs/GpsHyperionLinuxController.cpp
@ -44,21 +44,24 @@ LocalPoolDataSetBase *GpsHyperionLinuxController::getDataSetHandle(sid_t sid) {
 ReturnValue_t GpsHyperionLinuxController::checkModeCommand(Mode_t mode, Submode_t submode,
                                                           uint32_t *msToReachTheMode) {
-  if (mode == MODE_ON) {
+  if (not modeCommanded) {
-    maxTimeToReachFix.resetTimer();
+    if (mode == MODE_ON or mode == MODE_OFF) {
-    gainedNewFix.timeOut();
+      // 5h time to reach fix
-  } else if (mode == MODE_NORMAL) {
+      *msToReachTheMode = MAX_SECONDS_TO_REACH_FIX;
-    return HasModesIF::INVALID_MODE;
+      maxTimeToReachFix.resetTimer();
      modeCommanded = true;
    } else if (mode == MODE_NORMAL) {
      return HasModesIF::INVALID_MODE;
    }
  }
  if (mode == MODE_OFF) {
    maxTimeToReachFix.timeOut();
    gainedNewFix.timeOut();
    PoolReadGuard pg(&gpsSet);
    gpsSet.setValidity(false, true);
-    // The ctrl is off, so it cannot detect the data from the devices.
+    // There can't be a fix with a device that is off.
-    handleFixChangedEvent(GpsHyperion::FixMode::NOT_SEEN);
+    triggerEvent(GpsHyperion::GPS_FIX_CHANGE, gpsSet.fixMode.value, 0);
-    gpsSet.fixMode.value = GpsHyperion::FixMode::NOT_SEEN;
+    gpsSet.fixMode.value = 0;
    oneShotSwitches.reset();
    modeCommanded = false;
  }
  return returnvalue::OK;
 }
@ -72,16 +75,13 @@ ReturnValue_t GpsHyperionLinuxController::executeAction(ActionId_t actionId,
        PoolReadGuard pg(&gpsSet);
        // Set HK entries invalid
        gpsSet.setValidity(false, true);
-        ReturnValue_t result = resetCallback(data, size, resetCallbackArgs);
+        resetCallback(data, size, resetCallbackArgs);
        if (result != returnvalue::OK) {
          return result;
        }
        return HasActionsIF::EXECUTION_FINISHED;
      }
      return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
    }
  }
-  return HasActionsIF::INVALID_ACTION_ID;
+  return returnvalue::OK;
 }
 ReturnValue_t GpsHyperionLinuxController::initializeLocalDataPool(
@ -100,7 +100,7 @@ ReturnValue_t GpsHyperionLinuxController::initializeLocalDataPool(
  localDataPoolMap.emplace(GpsHyperion::SATS_IN_USE, new PoolEntry<uint8_t>());
  localDataPoolMap.emplace(GpsHyperion::SATS_IN_VIEW, new PoolEntry<uint8_t>());
  localDataPoolMap.emplace(GpsHyperion::FIX_MODE, new PoolEntry<uint8_t>());
-  poolManager.subscribeForRegularPeriodicPacket({gpsSet.getSid(), enableHkSets, 60.0});
+  poolManager.subscribeForRegularPeriodicPacket({gpsSet.getSid(), enableHkSets, 30.0});
  localDataPoolMap.emplace(GpsHyperion::SKYVIEW_UNIX_SECONDS, new PoolEntry<double>());
  localDataPoolMap.emplace(GpsHyperion::PRN_ID, new PoolEntry<int16_t>());
  localDataPoolMap.emplace(GpsHyperion::AZIMUTH, new PoolEntry<int16_t>());
@ -216,9 +216,15 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
  bool modeIsSet = true;
  if (MODE_SET != (MODE_SET & gps.set)) {
    if (mode != MODE_OFF) {
      if (maxTimeToReachFix.hasTimedOut() and oneShotSwitches.cantGetFixSwitch) {
        sif::warning << "GpsHyperionLinuxController: No mode could be set in allowed "
                     << maxTimeToReachFix.getTimeoutMs() / 1000 << " seconds" << std::endl;
        triggerEvent(GpsHyperion::CANT_GET_FIX, maxTimeToReachFix.getTimeoutMs());
        oneShotSwitches.cantGetFixSwitch = false;
      }
      modeIsSet = false;
    } else {
-      // GPS ctrl is off anyway, so do other handling
+      // GPS device is off anyway, so do other handling
      return returnvalue::FAILED;
    }
  }
@ -243,44 +249,27 @@ ReturnValue_t GpsHyperionLinuxController::handleCoreTelemetry(bool modeIsSet) {
  uint8_t newFix = 0;
  if (modeIsSet) {
    // 0: Not seen, 1: No fix, 2: 2D-Fix, 3: 3D-Fix
-    if (gps.fix.mode == GpsHyperion::FixMode::FIX_2D or
+    if (gps.fix.mode == 2 or gps.fix.mode == 3) {
        gps.fix.mode == GpsHyperion::FixMode::FIX_3D) {
      validFix = true;
      maxTimeToReachFix.resetTimer();
    }
    newFix = gps.fix.mode;
-  }
+    if (newFix == 0 or newFix == 1) {
-  if (gpsSet.fixMode.value != newFix) {
+      if (modeCommanded and maxTimeToReachFix.hasTimedOut()) {
-    handleFixChangedEvent(newFix);
+        // We are supposed to be on and functioning, but no fix was found
-  }
+        if (mode == MODE_ON or mode == MODE_NORMAL) {
-  gpsSet.fixMode = newFix;
+          mode = MODE_OFF;
  gpsSet.fixMode.setValid(modeIsSet);
  // We are supposed to be on and functioning, but no fix was found
  if (not validFix) {
    if (maxTimeToReachFix.hasTimedOut()) {
      // Set HK entries invalid
      gpsSet.setValidity(false, true);
      if (oneShotSwitches.cantGetFixSwitch) {
        sif::warning << "GpsHyperionLinuxController: No fix detected in allowed "
                     << maxTimeToReachFix.getTimeoutMs() / 1000 << " seconds" << std::endl;
        triggerEvent(GpsHyperion::CANT_GET_FIX, maxTimeToReachFix.getTimeoutMs());
        oneShotSwitches.cantGetFixSwitch = false;
        // Try resetting the devices
        if (resetCallback != nullptr) {
          uint8_t chip = GpsHyperion::GnssChip::A_SIDE;
          ReturnValue_t result = resetCallback(&chip, 1, resetCallbackArgs);
          if (result != returnvalue::OK) {
            triggerEvent(GpsHyperion::RESET_FAIL, chip);
          }
          chip = GpsHyperion::GnssChip::B_SIDE;
          result = resetCallback(&chip, 1, resetCallbackArgs);
          if (result != returnvalue::OK) {
            triggerEvent(GpsHyperion::RESET_FAIL, chip);
          }
        }
        modeCommanded = false;
      }
    }
  }
  if (gpsSet.fixMode.value != newFix) {
 #if OBSW_Q7S_EM != 1
    triggerEvent(GpsHyperion::GPS_FIX_CHANGE, gpsSet.fixMode.value, newFix);
 #endif
  }
  gpsSet.fixMode = newFix;
  gpsSet.fixMode.setValid(modeIsSet);
  // Only set on specific messages, so only set a valid flag to invalid
  // if not set for more than a full message set (10 messages here)
@ -293,12 +282,9 @@ ReturnValue_t GpsHyperionLinuxController::handleCoreTelemetry(bool modeIsSet) {
    }
    satNotSetCounter = 0;
  } else {
-    if (satNotSetCounter < 10) {
+    satNotSetCounter++;
-      satNotSetCounter++;
+    if (gpsSet.satInUse.isValid() and satNotSetCounter >= 10) {
    } else {
      gpsSet.satInUse.value = 0;
      gpsSet.satInUse.setValid(false);
      gpsSet.satInView.value = 0;
      gpsSet.satInView.setValid(false);
    }
  }
@ -306,24 +292,22 @@ ReturnValue_t GpsHyperionLinuxController::handleCoreTelemetry(bool modeIsSet) {
  // LATLON is set for every message, no need for a counter
  bool latValid = false;
  bool longValid = false;
-  if (modeIsSet) {
+  if (LATLON_SET == (LATLON_SET & gps.set)) {
-    if (LATLON_SET == (LATLON_SET & gps.set)) {
+    if (std::isfinite(gps.fix.latitude)) {
-      if (std::isfinite(gps.fix.latitude)) {
+      // Negative latitude -> South direction
-        // Negative latitude -> South direction
+      gpsSet.latitude.value = gps.fix.latitude;
-        gpsSet.latitude.value = gps.fix.latitude;
+      // As specified in gps.h: Only valid if mode >= 2
-        // As specified in gps.h: Only valid if mode >= 2
+      if (gps.fix.mode >= 2) {
-        if (gps.fix.mode >= GpsHyperion::FixMode::FIX_2D) {
+        latValid = true;
          latValid = true;
        }
      }
    }
-      if (std::isfinite(gps.fix.longitude)) {
+    if (std::isfinite(gps.fix.longitude)) {
-        // Negative longitude -> West direction
+      // Negative longitude -> West direction
-        gpsSet.longitude.value = gps.fix.longitude;
+      gpsSet.longitude.value = gps.fix.longitude;
-        // As specified in gps.h: Only valid if mode >= 2
+      // As specified in gps.h: Only valid if mode >= 2
-        if (gps.fix.mode >= GpsHyperion::FixMode::FIX_2D) {
+      if (gps.fix.mode >= 2) {
-          longValid = true;
+        longValid = true;
        }
      }
    }
  }
@ -332,24 +316,20 @@ ReturnValue_t GpsHyperionLinuxController::handleCoreTelemetry(bool modeIsSet) {
  // ALTITUDE is set for every message, no need for a counter
  bool altitudeValid = false;
-  if (modeIsSet) {
+  if (ALTITUDE_SET == (ALTITUDE_SET & gps.set) && std::isfinite(gps.fix.altitude)) {
-    if (ALTITUDE_SET == (ALTITUDE_SET & gps.set) && std::isfinite(gps.fix.altitude)) {
+    gpsSet.altitude.value = gps.fix.altitude;
-      gpsSet.altitude.value = gps.fix.altitude;
+    // As specified in gps.h: Only valid if mode == 3
-      // As specified in gps.h: Only valid if mode == 3
+    if (gps.fix.mode == 3) {
-      if (gps.fix.mode == GpsHyperion::FixMode::FIX_3D) {
+      altitudeValid = true;
        altitudeValid = true;
      }
    }
  }
  gpsSet.altitude.setValid(altitudeValid);
  // SPEED is set for every message, no need for a counter
  bool speedValid = false;
-  if (modeIsSet) {
+  if (SPEED_SET == (SPEED_SET & gps.set) && std::isfinite(gps.fix.speed)) {
-    if (SPEED_SET == (SPEED_SET & gps.set) && std::isfinite(gps.fix.speed)) {
+    gpsSet.speed.value = gps.fix.speed;
-      gpsSet.speed.value = gps.fix.speed;
+    speedValid = true;
      speedValid = true;
    }
  }
  gpsSet.speed.setValid(speedValid);
@ -450,14 +430,3 @@ void GpsHyperionLinuxController::overwriteTimeIfNotSane(timeval time, bool valid
    timeInit = true;
  }
 }
 void GpsHyperionLinuxController::handleFixChangedEvent(uint8_t newFix) {
  if (gainedNewFix.hasTimedOut()) {
    triggerEvent(GpsHyperion::GPS_FIX_CHANGE, newFix, fixChangeCounter);
    fixChangeCounter = 0;
    gainedNewFix.resetTimer();
    return;
  }
  fixChangeCounter++;
  gainedNewFix.resetTimer();
 }
--- a/linux/acs/GpsHyperionLinuxController.h
+++ b/linux/acs/GpsHyperionLinuxController.h
@ -1,13 +1,14 @@
 #ifndef MISSION_DEVICES_GPSHYPERIONHANDLER_H_
 #define MISSION_DEVICES_GPSHYPERIONHANDLER_H_
-#include <common/config/eive/eventSubsystemIds.h>
+#include <mission/acs/archive/GPSDefinitions.h>
 #include <fsfw/FSFW.h>
 #include <fsfw/controller/ExtendedControllerBase.h>
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <linux/acs/GPSDefinitions.h>
 #include <mission/utility/trace.h>
 #include "eive/eventSubsystemIds.h"
 #include "fsfw/FSFW.h"
 #include "fsfw/controller/ExtendedControllerBase.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #ifdef FSFW_OSAL_LINUX
 #include <gps.h>
 #include <libgpsmm.h>
@ -23,8 +24,8 @@
 */
 class GpsHyperionLinuxController : public ExtendedControllerBase {
 public:
-  // 15 minutes
+  // 30 minutes
-  static constexpr uint32_t MAX_SECONDS_TO_REACH_FIX = 60 * 15;
+  static constexpr uint32_t MAX_SECONDS_TO_REACH_FIX = 60 * 30;
  enum ReadModes { SHM = 0, SOCKET = 1 };
@ -64,8 +65,7 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
  const char* currentClientBuf = nullptr;
  ReadModes readMode = ReadModes::SOCKET;
  Countdown maxTimeToReachFix = Countdown(MAX_SECONDS_TO_REACH_FIX * 1000);
-  Countdown gainedNewFix = Countdown(60 * 2 * 1000);
+  bool modeCommanded = false;
  uint32_t fixChangeCounter = 0;
  bool timeInit = false;
  uint8_t satNotSetCounter = 0;
@ -92,8 +92,6 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
  // we set it with the roughly valid time from the GPS. For some reason, NTP might only work
  // if the time difference between sys time and current time is not too large
  void overwriteTimeIfNotSane(timeval time, bool validFix);
  void handleFixChangedEvent(uint8_t newFix);
 };
 #endif /* MISSION_DEVICES_GPSHYPERIONHANDLER_H_ */
--- a/linux/acs/StrComHandler.cpp
+++ b/linux/acs/StrComHandler.cpp
@ -54,7 +54,7 @@ ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
    switch (state) {
      case InternalState::POLL_ONE_REPLY: {
        // Stopwatch watch;
-        replyTimeout.setTimeout(400);
+        replyTimeout.setTimeout(200);
        readOneReply(static_cast<uint32_t>(state));
        {
          MutexGuard mg(lock);
@ -175,8 +175,7 @@ void StrComHandler::setDownloadImageName(std::string filename) {
 void StrComHandler::setFlashReadFilename(std::string filename) { flashRead.filename = filename; }
-ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname,
+ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname) {
                                                 startracker::FirmwareTarget target) {
  {
    MutexGuard mg(lock);
    if (state != InternalState::SLEEPING) {
@ -193,13 +192,8 @@ ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname,
  if (not std::filesystem::exists(flashWrite.fullname)) {
    return FILE_NOT_EXISTS;
  }
-  if (target == startracker::FirmwareTarget::MAIN) {
+  flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST);
-    flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST_MAIN);
+  flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST);
    flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST_MAIN);
  } else if (target == startracker::FirmwareTarget::BACKUP) {
    flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST_BACKUP);
    flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST_BACKUP);
  }
  {
    MutexGuard mg(lock);
    replyWasReceived = false;
@ -270,7 +264,7 @@ ReturnValue_t StrComHandler::performImageDownload() {
      file.close();
      return returnvalue::OK;
    }
-    prv_arc_pack_download_action_req(&downloadReq, cmdBuf.data(), &size);
+    arc_pack_download_action_req(&downloadReq, cmdBuf.data(), &size);
    result = sendAndRead(size, downloadReq.position);
    if (result != returnvalue::OK) {
      if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
@ -281,7 +275,7 @@ ReturnValue_t StrComHandler::performImageDownload() {
      file.close();
      return result;
    }
-    result = checkActionReply(replySize, "downloading image");
+    result = checkActionReply(replySize);
    if (result != returnvalue::OK) {
      if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
        serial::flushRxBuf(serialPort);
@ -349,12 +343,12 @@ ReturnValue_t StrComHandler::performImageUpload() {
    }
    file.seekg(uploadReq.position * SIZE_IMAGE_PART, file.beg);
    file.read(reinterpret_cast<char*>(uploadReq.data), SIZE_IMAGE_PART);
-    prv_arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
+    arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
    result = sendAndRead(size, uploadReq.position);
    if (result != returnvalue::OK) {
      return returnvalue::FAILED;
    }
-    result = checkActionReply(replyLen, "sky image upload");
+    result = checkActionReply(replyLen);
    if (result != returnvalue::OK) {
      return result;
    }
@ -375,12 +369,12 @@ ReturnValue_t StrComHandler::performImageUpload() {
    file.seekg(fullChunks * SIZE_IMAGE_PART, file.beg);
    file.read(reinterpret_cast<char*>(uploadReq.data), remainder);
    file.close();
-    prv_arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
+    arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
    result = sendAndRead(size, uploadReq.position);
    if (result != returnvalue::OK) {
      return returnvalue::FAILED;
    }
-    result = checkActionReply(replyLen, "sky image upload");
+    result = checkActionReply(replyLen);
    if (result != returnvalue::OK) {
      return result;
    }
@ -394,7 +388,8 @@ ReturnValue_t StrComHandler::performImageUpload() {
 ReturnValue_t StrComHandler::performFirmwareUpdate() {
  using namespace startracker;
  ReturnValue_t result = returnvalue::OK;
-  result = unlockAndEraseRegions(flashWrite.firstRegion, flashWrite.lastRegion);
+  result = unlockAndEraseRegions(static_cast<uint32_t>(startracker::FirmwareRegions::FIRST),
                                 static_cast<uint32_t>(startracker::FirmwareRegions::LAST));
  if (result != returnvalue::OK) {
    return result;
  }
@ -445,12 +440,12 @@ ReturnValue_t StrComHandler::performFlashWrite() {
      bytesWrittenInRegion = 0;
    }
    req.address = bytesWrittenInRegion;
-    prv_arc_pack_write_action_req(&req, cmdBuf.data(), &size);
+    arc_pack_write_action_req(&req, cmdBuf.data(), &size);
    result = sendAndRead(size, req.address);
    if (result != returnvalue::OK) {
      return result;
    }
-    result = checkActionReply(replyLen, "firmware image upload");
+    result = checkActionReply(replyLen);
    if (result != returnvalue::OK) {
      return result;
    }
@ -488,12 +483,12 @@ ReturnValue_t StrComHandler::performFlashWrite() {
    req.length = remainingBytes;
    totalBytesWritten += CHUNK_SIZE;
    bytesWrittenInRegion += remainingBytes;
-    prv_arc_pack_write_action_req(&req, cmdBuf.data(), &size);
+    arc_pack_write_action_req(&req, cmdBuf.data(), &size);
    result = sendAndRead(size, req.address);
    if (result != returnvalue::OK) {
      return result;
    }
-    result = checkActionReply(replyLen, "flash write");
+    result = checkActionReply(replyLen);
    if (result != returnvalue::OK) {
      return result;
    }
@ -536,7 +531,7 @@ ReturnValue_t StrComHandler::performFlashRead() {
    } else {
      req.length = CHUNK_SIZE;
    }
-    prv_arc_pack_read_action_req(&req, cmdBuf.data(), &size);
+    arc_pack_read_action_req(&req, cmdBuf.data(), &size);
    result = sendAndRead(size, req.address);
    if (result != returnvalue::OK) {
      if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
@ -547,7 +542,7 @@ ReturnValue_t StrComHandler::performFlashRead() {
      file.close();
      return result;
    }
-    result = checkActionReply(replyLen, "flash read");
+    result = checkActionReply(replyLen);
    if (result != returnvalue::OK) {
      if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
        serial::flushRxBuf(serialPort);
@ -589,7 +584,7 @@ ReturnValue_t StrComHandler::sendAndRead(size_t size, uint32_t failParameter) {
  return readOneReply(failParameter);
 }
-ReturnValue_t StrComHandler::checkActionReply(size_t replySize, const char* context) {
+ReturnValue_t StrComHandler::checkActionReply(size_t replySize) {
  uint8_t type = startracker::getReplyFrameType(replyPtr);
  if (type != TMTC_ACTIONREPLY) {
    sif::warning << "StrHelper::checkActionReply: Received reply with invalid type ID" << std::endl;
@ -597,7 +592,7 @@ ReturnValue_t StrComHandler::checkActionReply(size_t replySize, const char* cont
  }
  uint8_t status = startracker::getStatusField(replyPtr);
  if (status != ArcsecDatalinkLayer::STATUS_OK) {
-    sif::warning << "StrHelper::checkActionReply: Status failure for " << context << ": "
+    sif::warning << "StrHelper::checkActionReply: Status failure: "
                 << static_cast<unsigned int>(status) << std::endl;
    return STATUS_ERROR;
  }
@ -725,7 +720,7 @@ ReturnValue_t StrComHandler::readReceivedMessage(CookieIF* cookie, uint8_t** buf
  {
    MutexGuard mg(lock);
    if (state != InternalState::SLEEPING) {
-      return BUSY;
+      return returnvalue::OK;
    }
    replyWasReceived = this->replyWasReceived;
  }
@ -738,7 +733,7 @@ ReturnValue_t StrComHandler::readReceivedMessage(CookieIF* cookie, uint8_t** buf
    *size = replyLen;
  }
  replyLen = 0;
-  return replyResult;
+  return returnvalue::OK;
 }
 ReturnValue_t StrComHandler::unlockAndEraseRegions(uint32_t from, uint32_t to) {
@ -749,26 +744,23 @@ ReturnValue_t StrComHandler::unlockAndEraseRegions(uint32_t from, uint32_t to) {
  struct UnlockActionRequest unlockReq;
  struct EraseActionRequest eraseReq;
  uint32_t size = 0;
-  for (uint32_t idx = from; idx < to; idx++) {
+  for (uint32_t idx = from; idx <= to; idx++) {
    unlockReq.region = idx;
-    unlockReq.code = startracker::region_secrets::SECRETS[idx];
+    unlockReq.code = startracker::region_secrets::secret[idx];
-    prv_arc_pack_unlock_action_req(&unlockReq, cmdBuf.data(), &size);
+    arc_pack_unlock_action_req(&unlockReq, cmdBuf.data(), &size);
    result = sendAndRead(size, unlockReq.region);
    if (result != returnvalue::OK) {
      return result;
    }
-    result = checkActionReply(replyLen, "unlocking region");
+    result = checkActionReply(replyLen);
    if (result != returnvalue::OK) {
      sif::warning << "StrHelper::unlockAndEraseRegions: Failed to unlock region with id "
                   << static_cast<unsigned int>(unlockReq.region) << std::endl;
      return result;
    }
    eraseReq.region = idx;
-    prv_arc_pack_erase_action_req(&eraseReq, cmdBuf.data(), &size);
+    arc_pack_erase_action_req(&eraseReq, cmdBuf.data(), &size);
    result = sendAndRead(size, eraseReq.region);
    if (result != returnvalue::OK) {
    }
    result = checkActionReply(replyLen, "erasing region");
    if (result != returnvalue::OK) {
      sif::warning << "StrHelper::unlockAndEraseRegions: Failed to erase region with id "
                   << static_cast<unsigned int>(eraseReq.region) << std::endl;
--- a/linux/acs/StrComHandler.h
+++ b/linux/acs/StrComHandler.h
@ -6,7 +6,6 @@
 #include <string>
 #include "OBSWConfig.h"
 #include "mission/acs/str/strHelpers.h"
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/SdCardManager.h"
@ -128,7 +127,7 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
   * @param fullname    Full name including absolute path of file containing firmware
   *                    update.
   */
-  ReturnValue_t startFirmwareUpdate(std::string fullname, startracker::FirmwareTarget target);
+  ReturnValue_t startFirmwareUpdate(std::string fullname);
  /**
   * @brief   Starts the flash read procedure
@ -335,7 +334,7 @@ class StrComHandler : public SystemObject, public DeviceCommunicationIF, public
   *
   * @return  returnvalue::OK if reply confirms success of packet transfer, otherwise REUTRN_FAILED
   */
-  ReturnValue_t checkActionReply(size_t replySize, const char *context);
+  ReturnValue_t checkActionReply(size_t replySize);
  /**
   * @brief   Checks the position field in a star tracker upload/download reply.
--- a/linux/acs/SusPolling.cpp
+++ b/linux/acs/SusPolling.cpp
@ -170,12 +170,18 @@ ReturnValue_t SusPolling::handleSusPolling() {
      }
      MutexGuard mg(ipcLock);
      susDevs[idx].ownReply.tempRaw = ((rawReply[0] & 0x0f) << 8) | rawReply[1];
-      susDevs[idx].replyResult = returnvalue::OK;
+      // Reply is all ones. Sensor is probably off or faulty when
-      for (unsigned chIdx = 0; chIdx < 6; chIdx++) {
+      // it should not be.
-        susDevs[idx].ownReply.channelsRaw[chIdx] =
+      if (susDevs[idx].ownReply.tempRaw == 0x0fff) {
-            (rawReply[chIdx * 2 + 2] << 8) | rawReply[chIdx * 2 + 3];
+        susDevs[idx].replyResult = returnvalue::FAILED;
      } else {
        susDevs[idx].replyResult = returnvalue::OK;
        for (unsigned chIdx = 0; chIdx < 6; chIdx++) {
          susDevs[idx].ownReply.channelsRaw[chIdx] =
              (rawReply[chIdx * 2 + 2] << 8) | rawReply[chIdx * 2 + 3];
        }
        susDevs[idx].ownReply.dataWasSet = true;
      }
      susDevs[idx].ownReply.dataWasSet = true;
    }
  }
  return OK;
--- a/linux/callbacks/gpioCallbacks.cpp
+++ b/linux/callbacks/gpioCallbacks.cpp
@ -21,18 +21,6 @@ void gpioCallbacks::spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gp
  if (value == gpio::Levels::HIGH) {
    switch (gpioId) {
      case (gpioIds::RTD_IC_0): {
        disableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_1): {
        disableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_2): {
        disableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_3): {
        disableDecoderTcsIc1(gpioIF);
        break;
@ -54,15 +42,15 @@ void gpioCallbacks::spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gp
        break;
      }
      case (gpioIds::RTD_IC_8): {
-        disableDecoderTcsIc2(gpioIF);
+        disableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_9): {
-        disableDecoderTcsIc2(gpioIF);
+        disableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_10): {
-        disableDecoderTcsIc2(gpioIF);
+        disableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_11): {
@ -85,6 +73,18 @@ void gpioCallbacks::spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gp
        disableDecoderTcsIc2(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_16): {
        disableDecoderTcsIc2(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_17): {
        disableDecoderTcsIc2(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_18): {
        disableDecoderTcsIc2(gpioIF);
        break;
      }
      case (gpioIds::CS_SUS_0): {
        disableDecoderInterfaceBoardIc1(gpioIF);
        break;
@ -154,82 +154,82 @@ void gpioCallbacks::spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gp
    }
  } else if (value == gpio::Levels::LOW) {
    switch (gpioId) {
      case (gpioIds::RTD_IC_0): {
        selectY7(gpioIF);
        enableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_1): {
        selectY6(gpioIF);
        enableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_2): {
        selectY5(gpioIF);
        enableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_3): {
-        selectY4(gpioIF);
+        selectY7(gpioIF);
        enableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_4): {
-        selectY3(gpioIF);
+        selectY6(gpioIF);
        enableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_5): {
-        selectY2(gpioIF);
+        selectY5(gpioIF);
        enableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_6): {
-        selectY1(gpioIF);
+        selectY4(gpioIF);
        enableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_7): {
-        selectY0(gpioIF);
+        selectY3(gpioIF);
        enableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_8): {
        selectY2(gpioIF);
        enableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_9): {
        selectY1(gpioIF);
        enableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_10): {
        selectY0(gpioIF);
        enableDecoderTcsIc1(gpioIF);
        break;
      }
      case (gpioIds::RTD_IC_11): {
        selectY7(gpioIF);
        enableDecoderTcsIc2(gpioIF);
        break;
      }
-      case (gpioIds::RTD_IC_9): {
+      case (gpioIds::RTD_IC_12): {
        selectY6(gpioIF);
        enableDecoderTcsIc2(gpioIF);
        break;
      }
-      case (gpioIds::RTD_IC_10): {
+      case (gpioIds::RTD_IC_13): {
        selectY5(gpioIF);
        enableDecoderTcsIc2(gpioIF);
        break;
      }
-      case (gpioIds::RTD_IC_11): {
+      case (gpioIds::RTD_IC_14): {
        selectY4(gpioIF);
        enableDecoderTcsIc2(gpioIF);
        break;
      }
-      case (gpioIds::RTD_IC_12): {
+      case (gpioIds::RTD_IC_15): {
        selectY3(gpioIF);
        enableDecoderTcsIc2(gpioIF);
        break;
      }
-      case (gpioIds::RTD_IC_13): {
+      case (gpioIds::RTD_IC_16): {
        selectY2(gpioIF);
        enableDecoderTcsIc2(gpioIF);
        break;
      }
-      case (gpioIds::RTD_IC_14): {
+      case (gpioIds::RTD_IC_17): {
        selectY1(gpioIF);
        enableDecoderTcsIc2(gpioIF);
        break;
      }
-      case (gpioIds::RTD_IC_15): {
+      case (gpioIds::RTD_IC_18): {
        selectY0(gpioIF);
        enableDecoderTcsIc2(gpioIF);
        break;
--- a/linux/fsfwconfig/events/translateEvents.cpp
+++ b/linux/fsfwconfig/events/translateEvents.cpp
@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 325 translations.
+ * @brief    Auto-generated event translation file. Contains 304 translations.
 * @details
- * Generated on: 2024-05-06 13:47:38
+ * Generated on: 2023-08-21 15:54:29
 */
 #include "translateEvents.h"
@ -82,11 +82,8 @@ const char *BIT_LOCK_STRING = "BIT_LOCK";
 const char *BIT_LOCK_LOST_STRING = "BIT_LOCK_LOST";
 const char *FRAME_PROCESSING_FAILED_STRING = "FRAME_PROCESSING_FAILED";
 const char *CLOCK_SET_STRING = "CLOCK_SET";
 const char *CLOCK_DUMP_LEGACY_STRING = "CLOCK_DUMP_LEGACY";
 const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
 const char *CLOCK_DUMP_STRING = "CLOCK_DUMP";
-const char *CLOCK_DUMP_BEFORE_SETTING_TIME_STRING = "CLOCK_DUMP_BEFORE_SETTING_TIME";
+const char *CLOCK_SET_FAILURE_STRING = "CLOCK_SET_FAILURE";
 const char *CLOCK_DUMP_AFTER_SETTING_TIME_STRING = "CLOCK_DUMP_AFTER_SETTING_TIME";
 const char *TC_DELETION_FAILED_STRING = "TC_DELETION_FAILED";
 const char *TEST_STRING = "TEST";
 const char *CHANGE_OF_SETUP_PARAMETER_STRING = "CHANGE_OF_SETUP_PARAMETER";
@ -95,28 +92,19 @@ const char *MSG_QUEUE_ERROR_STRING = "MSG_QUEUE_ERROR";
 const char *SERIALIZATION_ERROR_STRING = "SERIALIZATION_ERROR";
 const char *FILESTORE_ERROR_STRING = "FILESTORE_ERROR";
 const char *FILENAME_TOO_LARGE_ERROR_STRING = "FILENAME_TOO_LARGE_ERROR";
 const char *HANDLING_CFDP_REQUEST_FAILED_STRING = "HANDLING_CFDP_REQUEST_FAILED";
 const char *SAFE_RATE_VIOLATION_STRING = "SAFE_RATE_VIOLATION";
-const char *RATE_RECOVERY_STRING = "RATE_RECOVERY";
+const char *SAFE_RATE_RECOVERY_STRING = "SAFE_RATE_RECOVERY";
 const char *MULTIPLE_RW_INVALID_STRING = "MULTIPLE_RW_INVALID";
 const char *MEKF_INVALID_INFO_STRING = "MEKF_INVALID_INFO";
 const char *MEKF_RECOVERY_STRING = "MEKF_RECOVERY";
 const char *MEKF_AUTOMATIC_RESET_STRING = "MEKF_AUTOMATIC_RESET";
-const char *PTG_CTRL_NO_ATTITUDE_INFORMATION_STRING = "PTG_CTRL_NO_ATTITUDE_INFORMATION";
+const char *MEKF_INVALID_MODE_VIOLATION_STRING = "MEKF_INVALID_MODE_VIOLATION";
 const char *SAFE_MODE_CONTROLLER_FAILURE_STRING = "SAFE_MODE_CONTROLLER_FAILURE";
 const char *TLE_TOO_OLD_STRING = "TLE_TOO_OLD";
 const char *TLE_FILE_READ_FAILED_STRING = "TLE_FILE_READ_FAILED";
 const char *PTG_RATE_VIOLATION_STRING = "PTG_RATE_VIOLATION";
 const char *DETUMBLE_TRANSITION_FAILED_STRING = "DETUMBLE_TRANSITION_FAILED";
 const char *SWITCH_CMD_SENT_STRING = "SWITCH_CMD_SENT";
 const char *SWITCH_HAS_CHANGED_STRING = "SWITCH_HAS_CHANGED";
 const char *SWITCHING_Q7S_DENIED_STRING = "SWITCHING_Q7S_DENIED";
 const char *FDIR_REACTION_IGNORED_STRING = "FDIR_REACTION_IGNORED";
 const char *DATASET_READ_FAILED_STRING = "DATASET_READ_FAILED";
 const char *VOLTAGE_OUT_OF_BOUNDS_STRING = "VOLTAGE_OUT_OF_BOUNDS";
 const char *TIMEDELTA_OUT_OF_BOUNDS_STRING = "TIMEDELTA_OUT_OF_BOUNDS";
 const char *POWER_LEVEL_LOW_STRING = "POWER_LEVEL_LOW";
 const char *POWER_LEVEL_CRITICAL_STRING = "POWER_LEVEL_CRITICAL";
 const char *GPIO_PULL_HIGH_FAILED_STRING = "GPIO_PULL_HIGH_FAILED";
 const char *GPIO_PULL_LOW_FAILED_STRING = "GPIO_PULL_LOW_FAILED";
 const char *HEATER_WENT_ON_STRING = "HEATER_WENT_ON";
@ -140,9 +128,6 @@ const char *EXE_FAILURE_STRING = "EXE_FAILURE";
 const char *MPSOC_HANDLER_CRC_FAILURE_STRING = "MPSOC_HANDLER_CRC_FAILURE";
 const char *MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING = "MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH";
 const char *MPSOC_SHUTDOWN_FAILED_STRING = "MPSOC_SHUTDOWN_FAILED";
 const char *SUPV_NOT_ON_STRING = "SUPV_NOT_ON";
 const char *SUPV_REPLY_TIMEOUT_STRING = "SUPV_REPLY_TIMEOUT";
 const char *CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE_STRING = "CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE";
 const char *SELF_TEST_I2C_FAILURE_STRING = "SELF_TEST_I2C_FAILURE";
 const char *SELF_TEST_SPI_FAILURE_STRING = "SELF_TEST_SPI_FAILURE";
 const char *SELF_TEST_ADC_FAILURE_STRING = "SELF_TEST_ADC_FAILURE";
@ -164,8 +149,6 @@ const char *SUPV_EXE_FAILURE_STRING = "SUPV_EXE_FAILURE";
 const char *SUPV_CRC_FAILURE_EVENT_STRING = "SUPV_CRC_FAILURE_EVENT";
 const char *SUPV_HELPER_EXECUTING_STRING = "SUPV_HELPER_EXECUTING";
 const char *SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING = "SUPV_MPSOC_SHUTDOWN_BUILD_FAILED";
 const char *SUPV_ACK_UNKNOWN_COMMAND_STRING = "SUPV_ACK_UNKNOWN_COMMAND";
 const char *SUPV_EXE_ACK_UNKNOWN_COMMAND_STRING = "SUPV_EXE_ACK_UNKNOWN_COMMAND";
 const char *SANITIZATION_FAILED_STRING = "SANITIZATION_FAILED";
 const char *MOUNTED_SD_CARD_STRING = "MOUNTED_SD_CARD";
 const char *SEND_MRAM_DUMP_FAILED_STRING = "SEND_MRAM_DUMP_FAILED";
@ -245,7 +228,6 @@ const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_12903_STRING = "SIDE_SWITCH_TRANS
 const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
 const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
 const char *CANT_GET_FIX_STRING = "CANT_GET_FIX";
 const char *RESET_FAIL_STRING = "RESET_FAIL";
 const char *P60_BOOT_COUNT_STRING = "P60_BOOT_COUNT";
 const char *BATT_MODE_STRING = "BATT_MODE";
 const char *BATT_MODE_CHANGED_STRING = "BATT_MODE_CHANGED";
@ -327,9 +309,6 @@ const char *DUMP_NOK_CANCELLED_STRING = "DUMP_NOK_CANCELLED";
 const char *DUMP_MISC_CANCELLED_STRING = "DUMP_MISC_CANCELLED";
 const char *DUMP_HK_CANCELLED_STRING = "DUMP_HK_CANCELLED";
 const char *DUMP_CFDP_CANCELLED_STRING = "DUMP_CFDP_CANCELLED";
 const char *TEMPERATURE_ALL_ONES_START_STRING = "TEMPERATURE_ALL_ONES_START";
 const char *TEMPERATURE_ALL_ONES_RECOVERY_STRING = "TEMPERATURE_ALL_ONES_RECOVERY";
 const char *FAULT_HANDLER_TRIGGERED_STRING = "FAULT_HANDLER_TRIGGERED";
 const char *translateEvents(Event event) {
  switch ((event & 0xFFFF)) {
@ -488,15 +467,9 @@ const char *translateEvents(Event event) {
    case (8900):
      return CLOCK_SET_STRING;
    case (8901):
-      return CLOCK_DUMP_LEGACY_STRING;
+      return CLOCK_DUMP_STRING;
    case (8902):
      return CLOCK_SET_FAILURE_STRING;
    case (8903):
      return CLOCK_DUMP_STRING;
    case (8904):
      return CLOCK_DUMP_BEFORE_SETTING_TIME_STRING;
    case (8905):
      return CLOCK_DUMP_AFTER_SETTING_TIME_STRING;
    case (9100):
      return TC_DELETION_FAILED_STRING;
    case (9700):
@ -513,12 +486,10 @@ const char *translateEvents(Event event) {
      return FILESTORE_ERROR_STRING;
    case (10804):
      return FILENAME_TOO_LARGE_ERROR_STRING;
    case (10805):
      return HANDLING_CFDP_REQUEST_FAILED_STRING;
    case (11200):
      return SAFE_RATE_VIOLATION_STRING;
    case (11201):
-      return RATE_RECOVERY_STRING;
+      return SAFE_RATE_RECOVERY_STRING;
    case (11202):
      return MULTIPLE_RW_INVALID_STRING;
    case (11203):
@ -528,17 +499,11 @@ const char *translateEvents(Event event) {
    case (11205):
      return MEKF_AUTOMATIC_RESET_STRING;
    case (11206):
-      return PTG_CTRL_NO_ATTITUDE_INFORMATION_STRING;
+      return MEKF_INVALID_MODE_VIOLATION_STRING;
    case (11207):
      return SAFE_MODE_CONTROLLER_FAILURE_STRING;
    case (11208):
      return TLE_TOO_OLD_STRING;
    case (11209):
      return TLE_FILE_READ_FAILED_STRING;
    case (11210):
      return PTG_RATE_VIOLATION_STRING;
    case (11211):
      return DETUMBLE_TRANSITION_FAILED_STRING;
    case (11300):
      return SWITCH_CMD_SENT_STRING;
    case (11301):
@ -547,16 +512,6 @@ const char *translateEvents(Event event) {
      return SWITCHING_Q7S_DENIED_STRING;
    case (11303):
      return FDIR_REACTION_IGNORED_STRING;
    case (11304):
      return DATASET_READ_FAILED_STRING;
    case (11305):
      return VOLTAGE_OUT_OF_BOUNDS_STRING;
    case (11306):
      return TIMEDELTA_OUT_OF_BOUNDS_STRING;
    case (11307):
      return POWER_LEVEL_LOW_STRING;
    case (11308):
      return POWER_LEVEL_CRITICAL_STRING;
    case (11400):
      return GPIO_PULL_HIGH_FAILED_STRING;
    case (11401):
@ -603,12 +558,6 @@ const char *translateEvents(Event event) {
      return MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH_STRING;
    case (11606):
      return MPSOC_SHUTDOWN_FAILED_STRING;
    case (11607):
      return SUPV_NOT_ON_STRING;
    case (11608):
      return SUPV_REPLY_TIMEOUT_STRING;
    case (11609):
      return CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE_STRING;
    case (11701):
      return SELF_TEST_I2C_FAILURE_STRING;
    case (11702):
@ -651,10 +600,6 @@ const char *translateEvents(Event event) {
      return SUPV_HELPER_EXECUTING_STRING;
    case (12008):
      return SUPV_MPSOC_SHUTDOWN_BUILD_FAILED_STRING;
    case (12009):
      return SUPV_ACK_UNKNOWN_COMMAND_STRING;
    case (12010):
      return SUPV_EXE_ACK_UNKNOWN_COMMAND_STRING;
    case (12100):
      return SANITIZATION_FAILED_STRING;
    case (12101):
@ -813,8 +758,6 @@ const char *translateEvents(Event event) {
      return GPS_FIX_CHANGE_STRING;
    case (13101):
      return CANT_GET_FIX_STRING;
    case (13102):
      return RESET_FAIL_STRING;
    case (13200):
      return P60_BOOT_COUNT_STRING;
    case (13201):
@ -977,12 +920,6 @@ const char *translateEvents(Event event) {
      return DUMP_HK_CANCELLED_STRING;
    case (14314):
      return DUMP_CFDP_CANCELLED_STRING;
    case (14500):
      return TEMPERATURE_ALL_ONES_START_STRING;
    case (14501):
      return TEMPERATURE_ALL_ONES_RECOVERY_STRING;
    case (14600):
      return FAULT_HANDLER_TRIGGERED_STRING;
    default:
      return "UNKNOWN_EVENT";
  }
--- a/linux/fsfwconfig/objects/translateObjects.cpp
+++ b/linux/fsfwconfig/objects/translateObjects.cpp
@ -1,17 +1,15 @@
 /**
 * @brief  Auto-generated object translation file.
 * @details
- * Contains 180 translations.
+ * Contains 175 translations.
- * Generated on: 2024-05-06 13:47:38
+ * Generated on: 2023-08-21 15:54:29
 */
 #include "translateObjects.h"
 const char *P60DOCK_TEST_TASK_STRING = "P60DOCK_TEST_TASK";
 const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
 const char *CORE_CONTROLLER_STRING = "CORE_CONTROLLER";
 const char *POWER_CONTROLLER_STRING = "POWER_CONTROLLER";
 const char *GLOBAL_JSON_CFG_STRING = "GLOBAL_JSON_CFG";
 const char *XIPHOS_WDT_STRING = "XIPHOS_WDT";
 const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *MGM_0_LIS3_HANDLER_STRING = "MGM_0_LIS3_HANDLER";
 const char *GYRO_0_ADIS_HANDLER_STRING = "GYRO_0_ADIS_HANDLER";
@ -64,7 +62,6 @@ const char *PTME_VC3_CFDP_TM_STRING = "PTME_VC3_CFDP_TM";
 const char *PLOC_MPSOC_HANDLER_STRING = "PLOC_MPSOC_HANDLER";
 const char *PLOC_SUPERVISOR_HANDLER_STRING = "PLOC_SUPERVISOR_HANDLER";
 const char *PLOC_SUPERVISOR_HELPER_STRING = "PLOC_SUPERVISOR_HELPER";
 const char *PLOC_MPSOC_COMMUNICATION_STRING = "PLOC_MPSOC_COMMUNICATION";
 const char *SCEX_STRING = "SCEX";
 const char *SOLAR_ARRAY_DEPL_HANDLER_STRING = "SOLAR_ARRAY_DEPL_HANDLER";
 const char *HEATER_HANDLER_STRING = "HEATER_HANDLER";
@ -167,13 +164,11 @@ const char *PUS_TM_FUNNEL_STRING = "PUS_TM_FUNNEL";
 const char *CFDP_TM_FUNNEL_STRING = "CFDP_TM_FUNNEL";
 const char *CFDP_HANDLER_STRING = "CFDP_HANDLER";
 const char *CFDP_DISTRIBUTOR_STRING = "CFDP_DISTRIBUTOR";
 const char *CFDP_FAULT_HANDLER_STRING = "CFDP_FAULT_HANDLER";
 const char *EIVE_SYSTEM_STRING = "EIVE_SYSTEM";
 const char *ACS_SUBSYSTEM_STRING = "ACS_SUBSYSTEM";
 const char *PL_SUBSYSTEM_STRING = "PL_SUBSYSTEM";
 const char *TCS_SUBSYSTEM_STRING = "TCS_SUBSYSTEM";
 const char *COM_SUBSYSTEM_STRING = "COM_SUBSYSTEM";
 const char *EPS_SUBSYSTEM_STRING = "EPS_SUBSYSTEM";
 const char *MISC_TM_STORE_STRING = "MISC_TM_STORE";
 const char *OK_TM_STORE_STRING = "OK_TM_STORE";
 const char *NOT_OK_TM_STORE_STRING = "NOT_OK_TM_STORE";
@ -195,12 +190,8 @@ const char *translateObject(object_id_t object) {
      return ACS_CONTROLLER_STRING;
    case 0x43000003:
      return CORE_CONTROLLER_STRING;
    case 0x43000004:
      return POWER_CONTROLLER_STRING;
    case 0x43000006:
      return GLOBAL_JSON_CFG_STRING;
    case 0x43000007:
      return XIPHOS_WDT_STRING;
    case 0x43400001:
      return THERMAL_CONTROLLER_STRING;
    case 0x44120006:
@ -305,8 +296,6 @@ const char *translateObject(object_id_t object) {
      return PLOC_SUPERVISOR_HANDLER_STRING;
    case 0x44330017:
      return PLOC_SUPERVISOR_HELPER_STRING;
    case 0x44330018:
      return PLOC_MPSOC_COMMUNICATION_STRING;
    case 0x44330032:
      return SCEX_STRING;
    case 0x444100A2:
@ -511,8 +500,6 @@ const char *translateObject(object_id_t object) {
      return CFDP_HANDLER_STRING;
    case 0x73000206:
      return CFDP_DISTRIBUTOR_STRING;
    case 0x73000207:
      return CFDP_FAULT_HANDLER_STRING;
    case 0x73010000:
      return EIVE_SYSTEM_STRING;
    case 0x73010001:
@ -523,8 +510,6 @@ const char *translateObject(object_id_t object) {
      return TCS_SUBSYSTEM_STRING;
    case 0x73010004:
      return COM_SUBSYSTEM_STRING;
    case 0x73010005:
      return EPS_SUBSYSTEM_STRING;
    case 0x73020001:
      return MISC_TM_STORE_STRING;
    case 0x73020002:
--- a/linux/ipcore/PapbVcInterface.cpp
+++ b/linux/ipcore/PapbVcInterface.cpp
@ -8,12 +8,8 @@
 #include "fsfw/serviceinterface/ServiceInterface.h"
 PapbVcInterface::PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId,
-                                 std::string uioFile, int mapNum, size_t maxPacketSize)
+                                 std::string uioFile, int mapNum)
-    : gpioComIF(gpioComIF),
+    : gpioComIF(gpioComIF), papbEmptyId(papbEmptyId), uioFile(std::move(uioFile)), mapNum(mapNum) {}
      papbEmptyId(papbEmptyId),
      packetBuf(maxPacketSize),
      uioFile(std::move(uioFile)),
      mapNum(mapNum) {}
 PapbVcInterface::~PapbVcInterface() {}
@ -27,66 +23,28 @@ ReturnValue_t PapbVcInterface::initialize() {
  return returnvalue::OK;
 }
-ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size, size_t& writtenSize) {
+ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
  // There are no packets smaller than 4, this is considered a configuration error.
  if (size < 4) {
    sif::warning << "PapbVcInterface::write: Passed packet smaller than 4 bytes" << std::endl;
    return returnvalue::FAILED;
  }
  // The user must call advance until completion before starting a new packet transfer.
  if (writeActiveStatus) {
    return IS_BUSY;
  }
  if (size > packetBuf.capacity()) {
    sif::error << "PapbVcInterface: Packet with size " << size << " larger than maximum configured"
               << " byte size " << packetBuf.capacity() << std::endl;
    return returnvalue::FAILED;
  }
  std::memcpy(packetBuf.data(), data, size);
  currentPacketSize = size;
  currentPacketIndex = 0;
  if (pollReadyForPacket()) {
    startPacketTransfer(ByteWidthCfg::ONE);
  } else {
    return DirectTmSinkIF::IS_BUSY;
  }
-  return advanceWrite(writtenSize);
+  if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
-}
+    abortPacketTransfer();
-
+    return returnvalue::FAILED;
 void PapbVcInterface::startPacketTransfer(ByteWidthCfg initWidth) {
  *vcBaseReg = CONFIG_DATA_INPUT | initWidth;
  writeActiveStatus = true;
 }
 bool PapbVcInterface::pollReadyForPacket() const {
  //  Check if PAPB interface is ready to receive data. Use the configuration register for this.
  //  Bit 5, see PTME ptme_001_01-0-7-r2 Table 31.
  uint32_t reg = *vcBaseReg;
  return (reg >> 6) & 0b1;
 }
 ReturnValue_t PapbVcInterface::advanceWrite(size_t& writtenSize) {
  if (!writeActiveStatus) {
    return NO_WRITE_ACTIVE;
  }
-  if (not pollReadyForPacket()) {
+  for (size_t idx = 0; idx < size; idx++) {
    return IS_BUSY;
  }
  while (currentPacketIndex < currentPacketSize) {
    if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
      if (not pollReadyForPacket()) {
        return PARTIALLY_WRITTEN;
      }
      abortPacketTransfer();
      return returnvalue::FAILED;
    }
-    *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(packetBuf[currentPacketIndex++]);
+    *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[idx]);
    writtenSize++;
  }
  if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
    if (not pollReadyForPacket()) {
      return PARTIALLY_WRITTEN;
    }
    abortPacketTransfer();
    return returnvalue::FAILED;
  }
@ -94,7 +52,18 @@ ReturnValue_t PapbVcInterface::advanceWrite(size_t& writtenSize) {
  return returnvalue::OK;
 }
-bool PapbVcInterface::writeActive() const { return writeActiveStatus; }
+void PapbVcInterface::startPacketTransfer(ByteWidthCfg initWidth) {
  *vcBaseReg = CONFIG_DATA_INPUT | initWidth;
 }
 void PapbVcInterface::completePacketTransfer() { *vcBaseReg = CONFIG_END; }
 bool PapbVcInterface::pollReadyForPacket() const {
  //  Check if PAPB interface is ready to receive data. Use the configuration register for this.
  //  Bit 5, see PTME ptme_001_01-0-7-r2 Table 31.
  uint32_t reg = *vcBaseReg;
  return (reg >> 6) & 0b1;
 }
 bool PapbVcInterface::isVcInterfaceBufferEmpty() {
  ReturnValue_t result = returnvalue::OK;
@ -132,16 +101,21 @@ inline bool PapbVcInterface::pollReadyForOctet(uint32_t maxCycles) const {
  return false;
 }
-void PapbVcInterface::abortPacketTransfer() {
+ReturnValue_t PapbVcInterface::sendTestFrame() {
-  *vcBaseReg = CONFIG_ABORT;
+  /** Size of one complete transfer frame data field amounts to 1105 bytes */
-  writeActiveStatus = false;
+  uint8_t testPacket[1105];
-  currentPacketIndex = 0;
+
-  currentPacketSize = 0;
+  /** Fill one test packet */
  for (int idx = 0; idx < 1105; idx++) {
    testPacket[idx] = static_cast<uint8_t>(idx & 0xFF);
  }
  ReturnValue_t result = write(testPacket, 1105);
  if (result != returnvalue::OK) {
    return result;
  }
  return returnvalue::OK;
 }
-void PapbVcInterface::completePacketTransfer() {
+void PapbVcInterface::abortPacketTransfer() { *vcBaseReg = CONFIG_ABORT; }
  *vcBaseReg = CONFIG_END;
  writeActiveStatus = false;
  currentPacketIndex = 0;
  currentPacketSize = 0;
 }
--- a/linux/ipcore/PapbVcInterface.h
+++ b/linux/ipcore/PapbVcInterface.h
@ -6,7 +6,6 @@
 #include <linux/ipcore/VirtualChannelIF.h>
 #include <atomic>
 #include <vector>
 #include "OBSWConfig.h"
 #include "fsfw/returnvalues/returnvalue.h"
@ -31,22 +30,20 @@ class PapbVcInterface : public VirtualChannelIF {
   * @param uioFile       UIO file providing access to the PAPB bus
   * @param mapNum        Map number of UIO map associated with this virtual channel
   */
-  PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId, std::string uioFile, int mapNum,
+  PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId, std::string uioFile, int mapNum);
                  size_t maxPacketSize);
  virtual ~PapbVcInterface();
  // See interface function documentation for docs on these functions.
  bool isBusy() const override;
-
+  /**
-  ReturnValue_t write(const uint8_t* data, size_t size, size_t& writtenSize) override;
+   *
-
+   * @param data
-  ReturnValue_t advanceWrite(size_t& remainingSize) override;
+   * @param size
   * @return returnvalue::OK on successfull write, PAPB_BUSY if PAPB is busy.
   */
  ReturnValue_t write(const uint8_t* data, size_t size) override;
  void cancelTransfer() override;
  bool writeActive() const override;
  ReturnValue_t initialize() override;
 private:
@ -89,14 +86,11 @@ class PapbVcInterface : public VirtualChannelIF {
  /** High when external buffer memory of virtual channel is empty */
  gpioId_t papbEmptyId = gpio::NO_GPIO;
  std::vector<uint8_t> packetBuf;
  std::string uioFile;
  int mapNum = 0;
  bool writeActiveStatus = false;
  size_t currentPacketIndex = 0;
  size_t currentPacketSize = 0;
  mutable struct timespec nextDelay = {.tv_sec = 0, .tv_nsec = 0};
  const struct timespec BETWEEN_POLL_DELAY = {.tv_sec = 0, .tv_nsec = 10};
  mutable struct timespec remDelay;
  volatile uint32_t* vcBaseReg = nullptr;
@ -132,6 +126,12 @@ class PapbVcInterface : public VirtualChannelIF {
   *          the packet buffer of the virtual channel or not.
   */
  bool isVcInterfaceBufferEmpty();
  /**
   * @brief   This function sends a complete telemetry transfer frame data field (1105 bytes)
   *          to the papb interface of the PTME IP Core. Can be used to test the implementation.
   */
  ReturnValue_t sendTestFrame();
 };
 #endif /* LINUX_OBC_PAPBVCINTERFACE_H_ */
--- a/linux/ipcore/PdecHandler.cpp
+++ b/linux/ipcore/PdecHandler.cpp
@ -24,15 +24,12 @@ using namespace pdec;
 uint32_t PdecHandler::CURRENT_FAR = 0;
 PdecHandler::PdecHandler(object_id_t objectId, object_id_t tcDestinationId,
-                         LinuxLibgpioIF* gpioComIF, gpioId_t pdecReset, UioNames names,
+                         LinuxLibgpioIF* gpioComIF, gpioId_t pdecReset, UioNames names)
                         uint32_t cfgMemPhyAddr, uint32_t pdecRamPhyAddr)
    : SystemObject(objectId),
      tcDestinationId(tcDestinationId),
      gpioComIF(gpioComIF),
      pdecReset(pdecReset),
      actionHelper(this, nullptr),
      cfgMemBaseAddr(cfgMemPhyAddr),
      pdecRamBaseAddr(pdecRamPhyAddr),
      uioNames(names),
      paramHelper(this) {
  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
@ -56,30 +53,23 @@ ReturnValue_t PdecHandler::initialize() {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
  ReturnValue_t result = returnvalue::OK;
  UioMapper regMapper(uioNames.registers);
-  ReturnValue_t result =
+  result = regMapper.getMappedAdress(&registerBaseAddress, UioMapper::Permissions::READ_WRITE);
      regMapper.getMappedAdress(&registerBaseAddress, UioMapper::Permissions::READ_WRITE);
  if (result != returnvalue::OK) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
-
+  UioMapper configMemMapper(uioNames.configMemory);
-  int fd = 0;
+  result = configMemMapper.getMappedAdress(&memoryBaseAddress, UioMapper::Permissions::READ_WRITE);
-  if ((fd = open("/dev/mem", O_RDWR | O_SYNC)) == -1) {
+  if (result != returnvalue::OK) {
    sif::error << "PdecHandler::initialize: Opening /dev/mem failed" << std::endl;
    return ObjectManagerIF::CHILD_INIT_FAILED;
  };
  memoryBaseAddress = static_cast<uint32_t*>(
      mmap(0, PDEC_CFG_MEM_SIZE, static_cast<int>(UioMapper::Permissions::READ_WRITE), MAP_SHARED,
           fd, cfgMemBaseAddr));
  if (memoryBaseAddress == nullptr) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  } else {
    pdecConfig.setMemoryBaseAddress(memoryBaseAddress);
  }
-  pdecConfig.setMemoryBaseAddress(memoryBaseAddress);
+  UioMapper ramMapper(uioNames.ramMemory);
-
+  result = ramMapper.getMappedAdress(&ramBaseAddress, UioMapper::Permissions::READ_WRITE);
-  ramBaseAddress = static_cast<uint32_t*>(mmap(0, PDEC_RAM_SIZE,
+  if (result != returnvalue::OK) {
                                               static_cast<int>(UioMapper::Permissions::READ_WRITE),
                                               MAP_SHARED, fd, pdecRamBaseAddr));
  if (ramBaseAddress == nullptr) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
@ -468,7 +458,14 @@ bool PdecHandler::newTcReceived() {
  return true;
 }
-void PdecHandler::doPeriodicWork() { checkLocks(); }
+void PdecHandler::doPeriodicWork() {
  // scuffed test code
  //  if(testCntr < 30) {
  //    triggerEvent(pdec::INVALID_TC_FRAME, FRAME_DIRTY_RETVAL);
  //    testCntr++;
  //  }
  checkLocks();
 }
 bool PdecHandler::checkFrameAna(uint32_t pdecFar) {
  bool frameValid = false;
@ -641,7 +638,7 @@ void PdecHandler::handleNewTc() {
 }
 ReturnValue_t PdecHandler::readTc(uint32_t& tcLength) {
-  uint32_t tcOffset = (*(registerBaseAddress + PDEC_BPTR_OFFSET) - pdecRamBaseAddr) / 4;
+  uint32_t tcOffset = (*(registerBaseAddress + PDEC_BPTR_OFFSET) - PHYSICAL_RAM_BASE_ADDRESS) / 4;
 #if OBSW_DEBUG_PDEC_HANDLER == 1
  sif::debug << "PdecHandler::readTc: TC offset: 0x" << std::hex << tcOffset << std::endl;
--- a/linux/ipcore/PdecHandler.h
+++ b/linux/ipcore/PdecHandler.h
@ -51,8 +51,6 @@ class PdecHandler : public SystemObject,
                    public ReceivesParameterMessagesIF {
 public:
  static constexpr dur_millis_t IRQ_TIMEOUT_MS = 500;
  static constexpr uint32_t PDEC_CFG_MEM_SIZE = 0x1000;
  static constexpr uint32_t PDEC_RAM_SIZE = 0x10000;
  enum class Modes { POLLED, IRQ };
@ -66,7 +64,7 @@ class PdecHandler : public SystemObject,
   * @param uioregsiters  String of uio device file same mapped to the PDEC register space
   */
  PdecHandler(object_id_t objectId, object_id_t tcDestinationId, LinuxLibgpioIF* gpioComIF,
-              gpioId_t pdecReset, UioNames names, uint32_t cfgMemPhyAddr, uint32_t pdecRamPhyAddr);
+              gpioId_t pdecReset, UioNames names);
  virtual ~PdecHandler();
@ -101,6 +99,12 @@ class PdecHandler : public SystemObject,
  static const size_t MAX_TC_SEGMENT_SIZE = 1017;
  static const uint8_t MAP_ID_MASK = 0x3F;
 #ifdef TE0720_1CFA
  static const uint32_t PHYSICAL_RAM_BASE_ADDRESS = 0x32000000;
 #else
  static const uint32_t PHYSICAL_RAM_BASE_ADDRESS = 0x26000000;
 #endif
  // Expected value stored in FAR register after reset
  static const uint32_t FAR_RESET = 0x7FE0;
@ -187,9 +191,6 @@ class PdecHandler : public SystemObject,
  MessageQueueId_t commandedBy = MessageQueueIF::NO_QUEUE;
  bool ptmeResetWithReinitializationPending = false;
  uint32_t cfgMemBaseAddr;
  uint32_t pdecRamBaseAddr;
  UioNames uioNames;
  ParameterHelper paramHelper;
--- a/linux/ipcore/Ptme.cpp
+++ b/linux/ipcore/Ptme.cpp
@ -19,12 +19,15 @@ ReturnValue_t Ptme::initialize() {
  return returnvalue::OK;
 }
-bool Ptme::containsVc(uint8_t vcId) const {
+ReturnValue_t Ptme::writeToVc(uint8_t vcId, const uint8_t* data, size_t size) {
-  auto channelIter = vcInterfaceMap.find(vcId);
+  VcInterfaceMapIter vcInterfaceMapIter = vcInterfaceMap.find(vcId);
-  if (channelIter == vcInterfaceMap.end()) {
+  if (vcInterfaceMapIter == vcInterfaceMap.end()) {
-    return false;
+    sif::warning << "Ptme::writeToVc: No virtual channel interface found for the virtual "
                    "channel with id "
                 << static_cast<unsigned int>(vcId) << std::endl;
    return UNKNOWN_VC_ID;
  }
-  return true;
+  return vcInterfaceMapIter->second->write(data, size);
 }
 void Ptme::addVcInterface(VcId_t vcId, VirtualChannelIF* vc) {
@ -47,10 +50,21 @@ void Ptme::addVcInterface(VcId_t vcId, VirtualChannelIF* vc) {
  }
 }
-VirtualChannelIF* Ptme::getVirtChannel(uint8_t vcId) {
+bool Ptme::isBusy(uint8_t vcId) const {
-  auto channelIter = vcInterfaceMap.find(vcId);
+  const auto& vcInterfaceMapIter = vcInterfaceMap.find(vcId);
-  if (channelIter == vcInterfaceMap.end()) {
+  if (vcInterfaceMapIter == vcInterfaceMap.end()) {
-    return nullptr;
+    sif::warning << "Ptme::writeToVc: No virtual channel interface found for the virtual "
                    "channel with id "
                 << static_cast<unsigned int>(vcId) << std::endl;
    return UNKNOWN_VC_ID;
  }
-  return channelIter->second;
+  return vcInterfaceMapIter->second->isBusy();
 }
 void Ptme::cancelTransfer(uint8_t vcId) {
  VcInterfaceMapIter vcInterfaceMapIter = vcInterfaceMap.find(vcId);
  if (vcInterfaceMapIter == vcInterfaceMap.end()) {
    return;
  }
  return vcInterfaceMapIter->second->cancelTransfer();
 }
--- a/linux/ipcore/Ptme.h
+++ b/linux/ipcore/Ptme.h
@ -34,8 +34,9 @@ class Ptme : public PtmeIF, public SystemObject {
  virtual ~Ptme();
  ReturnValue_t initialize() override;
-  bool containsVc(uint8_t vcId) const override;
+  ReturnValue_t writeToVc(uint8_t vcId, const uint8_t* data, size_t size) override;
-  VirtualChannelIF* getVirtChannel(uint8_t vcId) override;
+  bool isBusy(uint8_t vcId) const override;
  void cancelTransfer(uint8_t vcId) override;
  /**
   * @brief   This function adds the reference to a virtual channel interface to the vcInterface
--- a/linux/ipcore/PtmeIF.h
+++ b/linux/ipcore/PtmeIF.h
@ -1,8 +1,6 @@
 #ifndef LINUX_OBC_PTMEIF_H_
 #define LINUX_OBC_PTMEIF_H_
 #include <linux/ipcore/VirtualChannelIF.h>
 #include "fsfw/returnvalues/returnvalue.h"
 /**
@ -16,8 +14,16 @@ class PtmeIF {
 public:
  virtual ~PtmeIF(){};
-  virtual bool containsVc(uint8_t vcId) const = 0;
+  /**
-  virtual VirtualChannelIF* getVirtChannel(uint8_t vcId) = 0;
+   * @brief   Implements to function to write to a specific virtual channel.
   *
   * @param vcId  Virtual channel to write to
   * @param data  Pointer to buffer holding the data to write
   * @param size  Number of bytes to write
   */
  virtual ReturnValue_t writeToVc(uint8_t vcId, const uint8_t* data, size_t size) = 0;
  virtual bool isBusy(uint8_t vcId) const = 0;
  virtual void cancelTransfer(uint8_t vcId) = 0;
 };
 #endif /* LINUX_OBC_PTMEIF_H_ */
--- a/linux/payload/CMakeLists.txt
+++ b/linux/payload/CMakeLists.txt
@ -1,12 +1,10 @@
 target_sources(
  ${OBSW_NAME}
  PUBLIC PlocMemoryDumper.cpp
-         MpsocCommunication.cpp
+         PlocMpsocHandler.cpp
         SerialCommunicationHelper.cpp
         FreshMpsocHandler.cpp
         FreshSupvHandler.cpp
         PlocMpsocSpecialComHelper.cpp
         plocMpsocHelpers.cpp
         PlocSupervisorHandler.cpp
         PlocSupvUartMan.cpp
         ScexDleParser.cpp
         ScexHelper.cpp
--- a/linux/payload/FreshMpsocHandler.cpp
+++ b/linux/payload/FreshMpsocHandler.cpp
--- a/linux/payload/FreshMpsocHandler.h
+++ b/linux/payload/FreshMpsocHandler.h
@ -1,212 +0,0 @@
 #include "fsfw/action/ActionMessage.h"
 #include "fsfw/action/CommandsActionsIF.h"
 #include "fsfw/devicehandlers/DeviceHandlerIF.h"
 #include "fsfw/devicehandlers/FreshDeviceHandlerBase.h"
 #include "fsfw/ipc/MessageQueueIF.h"
 #include "fsfw/ipc/messageQueueDefinitions.h"
 #include "fsfw/modes/ModeMessage.h"
 #include "fsfw/objectmanager/SystemObjectIF.h"
 #include "fsfw/power/PowerSwitchIF.h"
 #include "fsfw/power/definitions.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw_hal/linux/gpio/Gpio.h"
 #include "linux/payload/MpsocCommunication.h"
 #include "linux/payload/PlocMpsocSpecialComHelper.h"
 #include "linux/payload/plocMpsocHelpers.h"
 class FreshMpsocHandler : public FreshDeviceHandlerBase, public CommandsActionsIF {
 public:
  enum OpCode { DEFAULT_OPERATION = 0, PARSE_TM = 1 };
  static constexpr uint32_t MPSOC_MODE_CMD_TIMEOUT_MS = 120000;
  FreshMpsocHandler(DhbConfig cfg, MpsocCommunication& comInterface,
                    PlocMpsocSpecialComHelper& specialComHelper, Gpio uartIsolatorSwitch,
                    object_id_t supervisorHandler, PowerSwitchIF& powerSwitcher,
                    power::Switch_t camSwitchId);
  /**
   * Periodic helper executed function, implemented by child class.
   */
  void performDeviceOperation(uint8_t opCode) override;
  void performDefaultDeviceOperation();
  /**
   * Implemented by child class. Handle all command messages which are
   * not health, mode, action or housekeeping messages.
   * @param message
   * @return
   */
  ReturnValue_t handleCommandMessage(CommandMessage* message) override;
  ReturnValue_t initialize() override;
 private:
  enum class StartupState { IDLE, HW_INIT, DONE } startupState = StartupState::IDLE;
  enum class PowerState { IDLE, PENDING_STARTUP, PENDING_SHUTDOWN, SUPV_FAILED, DONE };
  enum TransitionState { NONE, TO_ON, TO_OFF, SUBMODE } transitionState = TransitionState::NONE;
  MpsocCommunication& comInterface;
  PlocMpsocSpecialComHelper& specialComHelper;
  MessageQueueIF* eventQueue = nullptr;
  SourceSequenceCounter commandSequenceCount = SourceSequenceCounter(0);
  MessageQueueIF* commandActionHelperQueue = nullptr;
  CommandActionHelper commandActionHelper;
  Gpio uartIsolatorSwitch;
  mpsoc::HkReport hkReport;
  object_id_t supervisorHandler;
  Countdown mpsocBootTransitionCd = Countdown(6500);
  Countdown supvTransitionCd = Countdown(3000);
  PoolEntry<uint32_t> peStatus = PoolEntry<uint32_t>();
  PoolEntry<uint8_t> peMode = PoolEntry<uint8_t>();
  PoolEntry<uint8_t> peDownlinkPwrOn = PoolEntry<uint8_t>();
  PoolEntry<uint8_t> peDownlinkReplyActive = PoolEntry<uint8_t>();
  PoolEntry<uint8_t> peDownlinkJesdSyncStatus = PoolEntry<uint8_t>();
  PoolEntry<uint8_t> peDownlinkDacStatus = PoolEntry<uint8_t>();
  PoolEntry<uint8_t> peCameraStatus = PoolEntry<uint8_t>();
  PoolEntry<uint8_t> peCameraSdiStatus = PoolEntry<uint8_t>();
  PoolEntry<float> peCameraFpgaTemp = PoolEntry<float>();
  PoolEntry<float> peCameraSocTemp = PoolEntry<float>();
  PoolEntry<float> peSysmonTemp = PoolEntry<float>();
  PoolEntry<float> peSysmonVccInt = PoolEntry<float>();
  PoolEntry<float> peSysmonVccAux = PoolEntry<float>();
  PoolEntry<float> peSysmonVccBram = PoolEntry<float>();
  PoolEntry<float> peSysmonVccPaux = PoolEntry<float>();
  PoolEntry<float> peSysmonVccPint = PoolEntry<float>();
  PoolEntry<float> peSysmonVccPdro = PoolEntry<float>();
  PoolEntry<float> peSysmonMb12V = PoolEntry<float>();
  PoolEntry<float> peSysmonMb3V3 = PoolEntry<float>();
  PoolEntry<float> peSysmonMb1V8 = PoolEntry<float>();
  PoolEntry<float> peSysmonVcc12V = PoolEntry<float>();
  PoolEntry<float> peSysmonVcc5V = PoolEntry<float>();
  PoolEntry<float> peSysmonVcc3V3 = PoolEntry<float>();
  PoolEntry<float> peSysmonVcc3V3VA = PoolEntry<float>();
  PoolEntry<float> peSysmonVcc2V5DDR = PoolEntry<float>();
  PoolEntry<float> peSysmonVcc1V2DDR = PoolEntry<float>();
  PoolEntry<float> peSysmonVcc0V9 = PoolEntry<float>();
  PoolEntry<float> peSysmonVcc0V6VTT = PoolEntry<float>();
  PoolEntry<float> peSysmonSafeCotsCur = PoolEntry<float>();
  PoolEntry<float> peSysmonNvm4XoCur = PoolEntry<float>();
  PoolEntry<uint16_t> peSemUncorrectableErrs = PoolEntry<uint16_t>();
  PoolEntry<uint16_t> peSemCorrectableErrs = PoolEntry<uint16_t>();
  PoolEntry<uint8_t> peSemStatus = PoolEntry<uint8_t>();
  PoolEntry<uint8_t> peRebootMpsocRequired = PoolEntry<uint8_t>();
  PowerState powerState;
  bool specialComHelperExecuting = false;
  struct ActionCommandInfo {
    Countdown cmdCountdown = Countdown(mpsoc::DEFAULT_CMD_TIMEOUT_MS);
    bool pending = false;
    MessageQueueId_t commandedBy = MessageQueueIF::NO_QUEUE;
    DeviceCommandId_t pendingCmd = DeviceHandlerIF::NO_COMMAND_ID;
    uint16_t pendingCmdMpsocApid = 0;
    void reset() {
      pending = false;
      commandedBy = MessageQueueIF::NO_QUEUE;
      pendingCmd = DeviceHandlerIF::NO_COMMAND_ID;
    }
    void start(DeviceCommandId_t commandId, MessageQueueId_t commandedBy) {
      pending = true;
      cmdCountdown.resetTimer();
      pendingCmd = commandId;
      this->commandedBy = commandedBy;
    }
  } activeCmdInfo;
  uint8_t commandBuffer[mpsoc::MAX_COMMAND_SIZE];
  SpacePacketCreator creator;
  ploc::SpTcParams spParams = ploc::SpTcParams(creator);
  Mode_t targetMode = HasModesIF::MODE_UNDEFINED;
  Submode_t targetSubmode = 0;
  struct TmMemReadReport {
    static const uint8_t FIX_SIZE = 14;
    size_t rememberRequestedSize = 0;
  };
  TmMemReadReport tmMemReadReport;
  uint32_t lastReplySequenceCount = 0;
  uint8_t skipSupvCommandingToOn = false;
  PowerSwitchIF& powerSwitcher;
  power::Switch_t camSwitchId;
  // HK manager abstract functions.
  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                        LocalDataPoolManager& poolManager) override;
  // Mode abstract functions
  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                 uint32_t* msToReachTheMode) override;
  // Action override. Forward to user.
  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                              const uint8_t* data, size_t size) override;
  /**
   * @overload
   * @param submode
   */
  void startTransition(Mode_t newMode, Submode_t submode) override;
  ReturnValue_t performDeviceOperationPreQueueHandling(uint8_t opCode) override;
  // CommandsActionsIF overrides.
  MessageQueueIF* getCommandQueuePtr() override;
  void stepSuccessfulReceived(ActionId_t actionId, uint8_t step) override;
  void stepFailedReceived(ActionId_t actionId, uint8_t step, ReturnValue_t returnCode) override;
  void dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) override;
  void completionSuccessfulReceived(ActionId_t actionId) override;
  void completionFailedReceived(ActionId_t actionId, ReturnValue_t returnCode) override;
  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper* parameterWrapper,
                             const ParameterWrapper* newValues, uint16_t startAtIndex) override;
  void handleActionCommandFailure(ActionId_t actionId, ReturnValue_t returnCode);
  ReturnValue_t executeRegularCmd(ActionId_t actionId, MessageQueueId_t commandedBy,
                                  const uint8_t* data, size_t dataLen);
  void handleTransitionToOn();
  void handleTransitionToOff();
  ReturnValue_t commandTcModeReplay();
  ReturnValue_t commandTcMemWrite(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t commandTcMemRead(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t commandTcFlashDelete(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t commandTcReplayStart(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t commandTcReplayStop();
  ReturnValue_t commandTcDownlinkPwrOn(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t commandTcDownlinkPwrOff();
  ReturnValue_t commandTcGetHkReport();
  ReturnValue_t commandTcGetDirContent(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t commandTcReplayWriteSequence(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t commandTcCamCmdSend(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t commandTcModeIdle();
  ReturnValue_t commandTcCamTakePic(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t commandTcSimplexStreamFile(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t commandTcSplitFile(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t commandTcDownlinkDataModulate(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t commandTcModeSnapshot();
  ReturnValue_t finishAndSendTc(DeviceCommandId_t cmdId, mpsoc::TcBase& tcBase,
                                uint32_t cmdCountdown = mpsoc::DEFAULT_CMD_TIMEOUT_MS);
  void handleEvent(EventMessage* eventMessage);
  void cmdDoneHandler(bool success, ReturnValue_t result);
  ReturnValue_t handleDeviceReply();
  ReturnValue_t handleAckReport();
  ReturnValue_t handleExecutionReport();
  void sendFailureReport(DeviceCommandId_t replyId, ReturnValue_t status);
  ReturnValue_t reportReplyData(DeviceCommandId_t tmId);
  ReturnValue_t handleGetHkReport();
  bool handleHwStartup();
  bool handleHwShutdown();
  void stopSpecialComHelper();
  void commandSubmodeTransition();
  void commonSpecialComInit();
  void commonSpecialComStop();
  void commandInitHandling(ActionId_t actionId, MessageQueueId_t commandedBy);
 };
--- a/linux/payload/FreshSupvHandler.cpp
+++ b/linux/payload/FreshSupvHandler.cpp
--- a/linux/payload/FreshSupvHandler.h
+++ b/linux/payload/FreshSupvHandler.h
@ -1,188 +0,0 @@
 #ifndef LINUX_PAYLOAD_FRESHSUPVHANDLER_H_
 #define LINUX_PAYLOAD_FRESHSUPVHANDLER_H_
 #include <fsfw/power/PowerSwitchIF.h>
 #include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
 #include <map>
 #include "PlocSupvUartMan.h"
 #include "fsfw/devicehandlers/FreshDeviceHandlerBase.h"
 #include "fsfw/power/definitions.h"
 #include "fsfw_hal/linux/gpio/Gpio.h"
 #include "plocSupvDefs.h"
 using supv::TcBase;
 class FreshSupvHandler : public FreshDeviceHandlerBase {
 public:
  enum OpCode { DEFAULT_OPERATION = 0, PARSE_TM = 1 };
  FreshSupvHandler(DhbConfig cfg, CookieIF* comCookie, Gpio uartIsolatorSwitch,
                   PowerSwitchIF& switchIF, power::Switch_t powerSwitch);
  /**
   * Periodic helper executed function, implemented by child class.
   */
  void performDeviceOperation(uint8_t opCode) override;
  /**
   * Implemented by child class. Handle all command messages which are
   * not health, mode, action or housekeeping messages.
   * @param message
   * @return
   */
  ReturnValue_t handleCommandMessage(CommandMessage* message) override;
  ReturnValue_t initialize() override;
 private:
  // HK manager abstract functions.
  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                        LocalDataPoolManager& poolManager) override;
  // Mode abstract functions
  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                 uint32_t* msToReachTheMode) override;
  // Action override. Forward to user.
  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
                              const uint8_t* data, size_t size) override;
  /**
   * @overload
   * @param submode
   */
  void startTransition(Mode_t newMode, Submode_t submode) override;
  ReturnValue_t performDeviceOperationPreQueueHandling(uint8_t opCode) override;
  void handleTransitionToOn();
  void handleTransitionToOff();
 private:
  static constexpr bool SET_TIME_DURING_BOOT = true;
  static const uint8_t SIZE_NULL_TERMINATOR = 1;
  enum class StartupState : uint8_t {
    IDLE,
    POWER_SWITCHING,
    BOOTING,
    SET_TIME,
    WAIT_FOR_TIME_REPLY,
    TIME_WAS_SET,
    ON
  };
  StartupState startupState = StartupState::IDLE;
  MessageQueueIF* eventQueue = nullptr;
  supv::TmBase tmReader;
  enum class ShutdownState : uint8_t { IDLE, POWER_SWITCHING };
  ShutdownState shutdownState = ShutdownState::IDLE;
  PlocSupvUartManager* uartManager;
  CookieIF* comCookie;
  PowerSwitchIF& switchIF;
  power::Switch_t switchId;
  Gpio uartIsolatorSwitch;
  supv::HkSet hkSet;
  supv::BootStatusReport bootStatusReport;
  supv::LatchupStatusReport latchupStatusReport;
  supv::CountersReport countersReport;
  supv::AdcReport adcReport;
  bool transitionActive = false;
  Mode_t targetMode = HasModesIF::MODE_INVALID;
  Submode_t targetSubmode = 0;
  Countdown switchTimeout = Countdown(2000);
  // Vorago nees some time to boot properly
  Countdown bootTimeout = Countdown(supv::BOOT_TIMEOUT_MS);
  // Countdown interCmdCd = Countdown(supv::INTER_COMMAND_DELAY);
  PoolEntry<uint16_t> adcRawEntry = PoolEntry<uint16_t>(16);
  PoolEntry<uint16_t> adcEngEntry = PoolEntry<uint16_t>(16);
  PoolEntry<uint32_t> latchupCounters = PoolEntry<uint32_t>(7);
  PoolEntry<uint8_t> fmcStateEntry = PoolEntry<uint8_t>(1);
  PoolEntry<uint8_t> bootStateEntry = PoolEntry<uint8_t>(1);
  PoolEntry<uint8_t> bootCyclesEntry = PoolEntry<uint8_t>(1);
  PoolEntry<uint32_t> tempSupEntry = PoolEntry<uint32_t>(1);
  pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
  struct ActiveCmdInfo {
    ActiveCmdInfo(DeviceCommandId_t commandId, uint32_t cmdCountdownMs)
        : commandId(commandId), cmdCountdown(cmdCountdownMs) {}
    DeviceCommandId_t commandId = DeviceHandlerIF::NO_COMMAND_ID;
    bool isPending = false;
    bool ackRecv = false;
    bool ackExeRecv = false;
    bool replyPacketExpected = false;
    bool replyPacketReceived = false;
    MessageQueueId_t commandedBy = MessageQueueIF::NO_QUEUE;
    bool requiresActionReply = false;
    Countdown cmdCountdown;
  };
  uint32_t buildActiveCmdKey(uint16_t moduleApid, uint8_t serviceId);
  // Map for Action commands. For normal commands, a separate static structure will be used.
  std::map<uint32_t, ActiveCmdInfo> activeActionCmds;
  std::array<uint8_t, supv::MAX_COMMAND_SIZE> commandBuffer{};
  SpacePacketCreator creator;
  supv::TcParams spParams = supv::TcParams(creator);
  DeviceCommandId_t commandedByCached = MessageQueueIF::NO_QUEUE;
  ReturnValue_t parseTmPackets();
  ReturnValue_t sendCommand(DeviceCommandId_t commandId, TcBase& tc, bool replyPacketExpected,
                            uint32_t cmdCountdownMs = 1000);
  ReturnValue_t sendEmptyCmd(DeviceCommandId_t commandId, uint16_t apid, uint8_t serviceId,
                             bool replyPacketExpected);
  ReturnValue_t prepareSelBootImageCmd(const uint8_t* commandData);
  ReturnValue_t prepareSetTimeRefCmd();
  ReturnValue_t prepareSetBootTimeoutCmd(const uint8_t* commandData, size_t cmdDataLen);
  ReturnValue_t prepareRestartTriesCmd(const uint8_t* commandData, size_t cmdDataLen);
  ReturnValue_t prepareDisableHk();
  ReturnValue_t prepareLatchupConfigCmd(const uint8_t* commandData, DeviceCommandId_t deviceCommand,
                                        size_t cmdDataLen);
  ReturnValue_t prepareSetAlertLimitCmd(const uint8_t* commandData, size_t cmdDataLen);
  ReturnValue_t prepareFactoryResetCmd(const uint8_t* commandData, size_t len);
  ReturnValue_t prepareSetShutdownTimeoutCmd(const uint8_t* commandData, size_t cmdDataLen);
  ReturnValue_t prepareSetGpioCmd(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t prepareReadGpioCmd(const uint8_t* commandData, size_t commandDataLen);
  ReturnValue_t prepareSetAdcEnabledChannelsCmd(const uint8_t* commandData);
  ReturnValue_t prepareSetAdcWindowAndStrideCmd(const uint8_t* commandData);
  ReturnValue_t prepareSetAdcThresholdCmd(const uint8_t* commandData);
  ReturnValue_t prepareWipeMramCmd(const uint8_t* commandData, size_t cmdDataLen);
  ReturnValue_t extractUpdateCommand(const uint8_t* commandData, size_t size,
                                     supv::UpdateParams& params);
  ReturnValue_t extractBaseParams(const uint8_t** commandData, size_t& remSize,
                                  supv::UpdateParams& params);
  void handleEvent(EventMessage* eventMessage);
  void handleBadApidServiceCombination(Event event, unsigned int apid, unsigned int serviceId);
  ReturnValue_t eventSubscription();
  void handlePacketPrint();
  bool isCommandAlreadyActive(ActionId_t actionId) const;
  ReturnValue_t handleAckReport(const uint8_t* data);
  void printAckFailureInfo(uint16_t statusCode, DeviceCommandId_t commandId);
  ReturnValue_t handleExecutionReport(const uint8_t* data);
  ReturnValue_t handleExecutionSuccessReport(ActiveCmdInfo& info, supv::ExecutionReport& report);
  void handleExecutionFailureReport(ActiveCmdInfo& info, supv::ExecutionReport& report);
  ReturnValue_t handleHkReport(const uint8_t* data);
  ReturnValue_t verifyPacket(const uint8_t* start, size_t foundLen);
  void confirmReplyPacketReceived(supv::Apid apid, uint8_t serviceId);
  void performCommandCompletionHandling(supv::Apid apid, uint8_t serviceId, ActiveCmdInfo& info);
  ReturnValue_t handleBootStatusReport(const uint8_t* data);
  ReturnValue_t genericHandleTm(const char* contextString, const uint8_t* data,
                                LocalPoolDataSetBase& set, supv::Apid apid, uint8_t serviceId);
  ReturnValue_t handleLatchupStatusReport(const uint8_t* data);
  bool isCommandPending() const;
 };
 #endif /* LINUX_PAYLOAD_FRESHSUPVHANDLER_H_ */
--- a/linux/payload/MpsocCommunication.cpp
+++ b/linux/payload/MpsocCommunication.cpp
@ -1,75 +0,0 @@
 #include "MpsocCommunication.h"
 #include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
 #include "fsfw/tmtcpacket/ccsds/header.h"
 #include "linux/payload/plocMpsocHelpers.h"
 #include "unistd.h"
 MpsocCommunication::MpsocCommunication(object_id_t objectId, SerialConfig cfg)
    : SystemObject(objectId), readRingBuf(4096, true), helper(cfg) {}
 ReturnValue_t MpsocCommunication::initialize() { return helper.initialize(); }
 ReturnValue_t MpsocCommunication::send(const uint8_t* data, size_t dataLen) {
  if (MPSOC_LOW_LEVEL_TX_WIRETAPPING) {
    sif::debug << "SEND MPSOC packet with size " << dataLen << std::endl;
  }
  return helper.send(data, dataLen);
 }
 ReturnValue_t MpsocCommunication::parseAndRetrieveNextPacket() {
  // We do not have a data link layer, so this whole thing is a mess in any case..
  // But basically, we try to parse space packets from the internal ring buffer and trasnfer
  // them to the higher level device handler. The CRC check is performed here as well, with
  // few other ways to detect if we even have a valid packet.
  size_t availableReadData = readRingBuf.getAvailableReadData();
  // Minimum valid size for a space packet header.
  if (availableReadData < ccsds::HEADER_LEN + 1) {
    return returnvalue::OK;
  }
  readRingBuf.readData(readBuf, availableReadData);
  spReader.setReadOnlyData(readBuf, sizeof(readBuf));
  auto res = spReader.checkSize();
  if (res != returnvalue::OK) {
    return res;
  }
  // The packet might be garbage, with no way to recover without a data link layer.
  if (spReader.getFullPacketLen() > 4096) {
    readRingBuf.clear();
    // TODO: Maybe we should also clear the serial input buffer in Linux?
    return FAULTY_PACKET_SIZE;
  }
  if (availableReadData < spReader.getFullPacketLen()) {
    // Might be split packet where the rest still has to be read.
    return returnvalue::OK;
  }
  if (CRC::crc16ccitt(readBuf, spReader.getFullPacketLen()) != 0) {
    // Possibly invalid packet. We can not even trust the detected packet length.
    // Just clear the whole read buffer as well.
    readRingBuf.clear();
    triggerEvent(mpsoc::CRC_FAILURE);
    return CRC_CHECK_FAILED;
  }
  readRingBuf.deleteData(spReader.getFullPacketLen());
  return PACKET_RECEIVED;
 }
 ReturnValue_t MpsocCommunication::readSerialInterface() {
  int bytesRead = read(helper.rawFd(), readBuf, sizeof(readBuf));
  if (bytesRead < 0) {
    return returnvalue::FAILED;
  }
  if (bytesRead > 0) {
    if (MPSOC_LOW_LEVEL_RX_WIRETAPPING) {
      sif::debug << "Read " << bytesRead << " bytes on the MPSoC interface" << std::endl;
    }
    return readRingBuf.writeData(readBuf, bytesRead);
  }
  return returnvalue::OK;
 }
 const SpacePacketReader& MpsocCommunication::getSpReader() const { return spReader; }
 SerialCommunicationHelper& MpsocCommunication::getComHelper() { return helper; }
--- a/linux/payload/MpsocCommunication.h
+++ b/linux/payload/MpsocCommunication.h
@ -1,44 +0,0 @@
 #pragma once
 #include <fsfw/objectmanager/SystemObject.h>
 #include "eive/resultClassIds.h"
 #include "fsfw/container/SimpleRingBuffer.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
 #include "linux/payload/SerialCommunicationHelper.h"
 static constexpr bool MPSOC_LOW_LEVEL_TX_WIRETAPPING = false;
 static constexpr bool MPSOC_LOW_LEVEL_RX_WIRETAPPING = false;
 class MpsocCommunication : public SystemObject {
 public:
  static const uint8_t CLASS_ID = CLASS_ID::PLOC_MPSOC_COM;
  static constexpr ReturnValue_t PACKET_RECEIVED = returnvalue::makeCode(CLASS_ID, 0);
  static constexpr ReturnValue_t FAULTY_PACKET_SIZE = returnvalue::makeCode(CLASS_ID, 1);
  static constexpr ReturnValue_t CRC_CHECK_FAILED = returnvalue::makeCode(CLASS_ID, 2);
  MpsocCommunication(object_id_t objectId, SerialConfig cfg);
  ReturnValue_t initialize() override;
  ReturnValue_t send(const uint8_t* data, size_t dataLen);
  // Should be called periodically to transfer the received data from the MPSoC from the Linux
  // buffer to the internal ring buffer for further processing.
  ReturnValue_t readSerialInterface();
  // Parses the internal ring buffer for packets and checks whether a packet was received.
  ReturnValue_t parseAndRetrieveNextPacket();
  // Can be used to read the parse packet, if one was received.
  const SpacePacketReader& getSpReader() const;
  SerialCommunicationHelper& getComHelper();
 private:
  SpacePacketReader spReader;
  uint8_t readBuf[4096];
  SimpleRingBuffer readRingBuf;
  SerialCommunicationHelper helper;
 };
--- a/linux/payload/PlocMpsocHandler.cpp
+++ b/linux/payload/PlocMpsocHandler.cpp
@ -2,15 +2,14 @@
 #include <linux/payload/PlocMpsocHandler.h>
 #include <linux/payload/plocSupvDefs.h>
 #include <sstream>
 #include "OBSWConfig.h"
 #include "fsfw/datapool/PoolReadGuard.h"
 #include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/parameters/HasParametersIF.h"
 PlocMpsocHandler::PlocMpsocHandler(object_id_t objectId, object_id_t uartComIFid,
-                                   CookieIF* comCookie,
+                                   CookieIF* comCookie, PlocMpsocSpecialComHelper* plocMPSoCHelper,
                                   PlocMpsocSpecialComHelperLegacy* plocMPSoCHelper,
                                   Gpio uartIsolatorSwitch, object_id_t supervisorHandler)
    : DeviceHandlerBase(objectId, uartComIFid, comCookie),
      hkReport(this),
@ -21,8 +20,9 @@ PlocMpsocHandler::PlocMpsocHandler(object_id_t objectId, object_id_t uartComIFid
  if (comCookie == nullptr) {
    sif::error << "PlocMPSoCHandler: Invalid communication cookie" << std::endl;
  }
-  eventQueue = QueueFactory::instance()->createMessageQueue(10);
+  eventQueue = QueueFactory::instance()->createMessageQueue(EventMessage::EVENT_MESSAGE_SIZE * 5);
-  commandActionHelperQueue = QueueFactory::instance()->createMessageQueue(10);
+  commandActionHelperQueue =
      QueueFactory::instance()->createMessageQueue(EventMessage::EVENT_MESSAGE_SIZE * 5);
  spParams.maxSize = sizeof(commandBuffer);
  spParams.buf = commandBuffer;
 }
@ -54,26 +54,24 @@ ReturnValue_t PlocMpsocHandler::initialize() {
    return result;
  }
  result = manager->subscribeToEvent(
-      eventQueue->getId(),
+      eventQueue->getId(), event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_WRITE_FAILED));
      event::getEventId(PlocMpsocSpecialComHelperLegacy::MPSOC_FLASH_WRITE_FAILED));
  if (result != returnvalue::OK) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
  result = manager->subscribeToEvent(
      eventQueue->getId(),
-      event::getEventId(PlocMpsocSpecialComHelperLegacy::MPSOC_FLASH_WRITE_SUCCESSFUL));
+      event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_WRITE_SUCCESSFUL));
  if (result != returnvalue::OK) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
  result = manager->subscribeToEvent(
      eventQueue->getId(),
-      event::getEventId(PlocMpsocSpecialComHelperLegacy::MPSOC_FLASH_READ_SUCCESSFUL));
+      event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_READ_SUCCESSFUL));
  if (result != returnvalue::OK) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
  result = manager->subscribeToEvent(
-      eventQueue->getId(),
+      eventQueue->getId(), event::getEventId(PlocMpsocSpecialComHelper::MPSOC_FLASH_READ_FAILED));
      event::getEventId(PlocMpsocSpecialComHelperLegacy::MPSOC_FLASH_READ_FAILED));
  if (result != returnvalue::OK) {
    return ObjectManagerIF::CHILD_INIT_FAILED;
  }
@ -93,8 +91,6 @@ ReturnValue_t PlocMpsocHandler::initialize() {
 void PlocMpsocHandler::performOperationHook() {
  if (commandIsPending and cmdCountdown.hasTimedOut()) {
    sif::warning << "PlocMpsocHandler: Command " << getPendingCommand() << " has timed out"
                 << std::endl;
    commandIsPending = false;
    // TODO: Better returnvalue?
    cmdDoneHandler(false, returnvalue::FAILED);
@ -141,7 +137,7 @@ ReturnValue_t PlocMpsocHandler::executeAction(ActionId_t actionId, MessageQueueI
  }
  if (specialComHelperExecuting) {
-    return mpsoc::MPSOC_HELPER_EXECUTING;
+    return MPSoCReturnValuesIF::MPSOC_HELPER_EXECUTING;
  }
  switch (actionId) {
@ -192,33 +188,79 @@ void PlocMpsocHandler::doStartUp() {
    startupState = StartupState::HW_INIT;
  }
  if (startupState == StartupState::HW_INIT) {
-    if (handleHwStartup()) {
+#ifdef XIPHOS_Q7S
 #if not OBSW_MPSOC_JTAG_BOOT == 1
    switch (powerState) {
      case PowerState::OFF:
        commandActionHelper.commandAction(supervisorHandler, supv::START_MPSOC);
        powerState = PowerState::BOOTING;
        return;
      case PowerState::ON:
        uartIsolatorSwitch.pullHigh();
        startupState = StartupState::WAIT_CYCLES;
        break;
      default:
        return;
    }
 #else
    uartIsolatorSwitch.pullHigh();
    startupState = StartupState::WAIT_CYCLES;
 #endif /* not MSPOC_JTAG_BOOT == 1 */
 #else
    startupState = StartupState::WAIT_CYCLES;
    powerState = PowerState::ON;
 #endif /* XIPHOS_Q7S */
  }
  // Need to wait, MPSoC still not booted properly, requesting HK without these wait cycles does
  // not work, no replies..
  if (startupState == StartupState::WAIT_CYCLES) {
    waitCycles++;
    if (waitCycles >= 8) {
      startupState = StartupState::DONE;
      waitCycles = 0;
    }
  }
  if (startupState == StartupState::DONE) {
    setMode(_MODE_TO_ON);
    hkReport.setReportingEnabled(true);
    powerState = PowerState::IDLE;
    startupState = StartupState::IDLE;
  }
 }
 void PlocMpsocHandler::doShutDown() {
-  if (handleHwShutdown()) {
+#ifdef XIPHOS_Q7S
-    hkReport.setReportingEnabled(false);
+#if not OBSW_MPSOC_JTAG_BOOT == 1
-    setMode(_MODE_POWER_DOWN);
+  if (powerState == PowerState::ON) {
-    commandIsPending = false;
+    uartIsolatorSwitch.pullLow();
-    sequenceCount = 0;
+    commandActionHelper.commandAction(supervisorHandler, supv::SHUTDOWN_MPSOC);
-    powerState = PowerState::IDLE;
+    powerState = PowerState::SHUTDOWN;
-    startupState = StartupState::IDLE;
+    return;
  } else if (powerState == PowerState::SHUTDOWN) {
    // Wait till power state is OFF.
    return;
  }
 #else
  uartIsolatorSwitch.pullLow();
  powerState = PowerState::OFF;
 #endif
 #endif
  if (specialComHelper != nullptr) {
    specialComHelper->stopProcess();
  }
  hkReport.setReportingEnabled(false);
  setMode(_MODE_POWER_DOWN);
  commandIsPending = false;
  sequenceCount = 0;
  specialComHelperExecuting = false;
  startupState = StartupState::IDLE;
 }
 ReturnValue_t PlocMpsocHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
  if (not commandIsPending and not specialComHelperExecuting) {
    *id = mpsoc::TC_GET_HK_REPORT;
    commandIsPending = true;
    cmdCountdown.resetTimer();
    return buildCommandFromCommand(*id, nullptr, 0);
  }
  return NOTHING_TO_SEND;
@ -355,11 +397,6 @@ ReturnValue_t PlocMpsocHandler::scanForReply(const uint8_t* start, size_t remain
  SpacePacketReader spacePacket;
  spacePacket.setReadOnlyData(start, remainingSize);
  if (DEBUG_MPSOC_COMMUNICATION) {
    sif::debug << "RECV MPSOC packet. APID 0x" << std::hex << std::setw(3) << spacePacket.getApid()
               << std::dec << " Size " << spacePacket.getFullPacketLen() << " SSC "
               << spacePacket.getSequenceCount() << std::endl;
  }
  if (spacePacket.isNull()) {
    return returnvalue::FAILED;
  }
@ -410,7 +447,7 @@ ReturnValue_t PlocMpsocHandler::scanForReply(const uint8_t* start, size_t remain
      sif::debug << "PlocMPSoCHandler::scanForReply: Reply has invalid APID 0x" << std::hex
                 << std::setfill('0') << std::setw(2) << apid << std::dec << std::endl;
      *foundLen = remainingSize;
-      return mpsoc::INVALID_APID;
+      return MPSoCReturnValuesIF::INVALID_APID;
    }
  }
@ -447,7 +484,7 @@ ReturnValue_t PlocMpsocHandler::interpretDeviceReply(DeviceCommandId_t id, const
    }
    case (mpsoc::TM_FLASH_DIRECTORY_CONTENT): {
      result = verifyPacket(packet, foundPacketLen);
-      if (result == mpsoc::CRC_FAILURE) {
+      if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
        sif::warning << "PLOC MPSoC: Flash directory content reply invalid CRC" << std::endl;
      }
      /** Send data to commanding queue */
@ -475,7 +512,7 @@ void PlocMpsocHandler::setNormalDatapoolEntriesInvalid() {
  hkReport.setValidity(false, true);
 }
-uint32_t PlocMpsocHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 15000; }
+uint32_t PlocMpsocHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 10000; }
 ReturnValue_t PlocMpsocHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                        LocalDataPoolManager& poolManager) {
@ -559,7 +596,7 @@ ReturnValue_t PlocMpsocHandler::prepareTcMemRead(const uint8_t* commandData,
 ReturnValue_t PlocMpsocHandler::prepareTcFlashDelete(const uint8_t* commandData,
                                                     size_t commandDataLen) {
  if (commandDataLen > config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE) {
-    return mpsoc::NAME_TOO_LONG;
+    return MPSoCReturnValuesIF::NAME_TOO_LONG;
  }
  ReturnValue_t result = returnvalue::OK;
  mpsoc::TcFlashDelete tcFlashDelete(spParams, sequenceCount);
@ -708,19 +745,12 @@ ReturnValue_t PlocMpsocHandler::finishTcPrep(mpsoc::TcBase& tcBase) {
  rawPacket = commandBuffer;
  rawPacketLen = tcBase.getFullPacketLen();
  sequenceCount++;
  if (DEBUG_MPSOC_COMMUNICATION) {
    sif::debug << "SEND MPSOC packet. APID 0x" << std::hex << std::setw(3) << tcBase.getApid()
               << " Size " << std::dec << tcBase.getFullPacketLen() << " SSC "
               << tcBase.getSeqCount() << std::endl;
  }
  cmdCountdown.resetTimer();
  return returnvalue::OK;
 }
 ReturnValue_t PlocMpsocHandler::verifyPacket(const uint8_t* start, size_t foundLen) {
  if (CRC::crc16ccitt(start, foundLen) != 0) {
-    return mpsoc::CRC_FAILURE;
+    return MPSoCReturnValuesIF::CRC_FAILURE;
  }
  return returnvalue::OK;
 }
@ -729,12 +759,12 @@ ReturnValue_t PlocMpsocHandler::handleAckReport(const uint8_t* data) {
  ReturnValue_t result = returnvalue::OK;
  result = verifyPacket(data, mpsoc::SIZE_ACK_REPORT);
-  if (result == mpsoc::CRC_FAILURE) {
+  if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
    sif::warning << "PlocMPSoCHandler::handleAckReport: CRC failure" << std::endl;
    nextReplyId = mpsoc::NONE;
    replyRawReplyIfnotWiretapped(data, mpsoc::SIZE_ACK_REPORT);
    triggerEvent(MPSOC_HANDLER_CRC_FAILURE);
-    sendFailureReport(mpsoc::ACK_REPORT, mpsoc::CRC_FAILURE);
+    sendFailureReport(mpsoc::ACK_REPORT, MPSoCReturnValuesIF::CRC_FAILURE);
    disableAllReplies();
    return IGNORE_REPLY_DATA;
  }
@ -773,7 +803,7 @@ ReturnValue_t PlocMpsocHandler::handleExecutionReport(const uint8_t* data) {
  ReturnValue_t result = returnvalue::OK;
  result = verifyPacket(data, mpsoc::SIZE_EXE_REPORT);
-  if (result == mpsoc::CRC_FAILURE) {
+  if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
    sif::warning << "PlocMPSoCHandler::handleExecutionReport: CRC failure" << std::endl;
    nextReplyId = mpsoc::NONE;
    return result;
@ -794,9 +824,9 @@ ReturnValue_t PlocMpsocHandler::handleExecutionReport(const uint8_t* data) {
      uint16_t status = mpsoc::getStatusFromRawData(data);
      sif::warning << "MPSoC EXE Failure: " << mpsoc::getStatusString(status) << std::endl;
      triggerEvent(EXE_FAILURE, commandId, status);
-      sendFailureReport(mpsoc::EXE_REPORT, mpsoc::RECEIVED_EXE_FAILURE);
+      sendFailureReport(mpsoc::EXE_REPORT, MPSoCReturnValuesIF::RECEIVED_EXE_FAILURE);
      result = IGNORE_REPLY_DATA;
-      cmdDoneHandler(false, mpsoc::RECEIVED_EXE_FAILURE);
+      cmdDoneHandler(false, MPSoCReturnValuesIF::RECEIVED_EXE_FAILURE);
      break;
    }
    default: {
@ -812,7 +842,7 @@ ReturnValue_t PlocMpsocHandler::handleExecutionReport(const uint8_t* data) {
 ReturnValue_t PlocMpsocHandler::handleMemoryReadReport(const uint8_t* data) {
  ReturnValue_t result = returnvalue::OK;
  result = verifyPacket(data, tmMemReadReport.rememberRequestedSize);
-  if (result == mpsoc::CRC_FAILURE) {
+  if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
    sif::warning << "PlocMPSoCHandler::handleMemoryReadReport: Memory read report has invalid crc"
                 << std::endl;
  }
@ -1000,13 +1030,12 @@ ReturnValue_t PlocMpsocHandler::handleGetHkReport(const uint8_t* data) {
  if (result != returnvalue::OK) {
    return result;
  }
  hkReport.setValidity(true, true);
  return returnvalue::OK;
 }
 ReturnValue_t PlocMpsocHandler::handleCamCmdRpt(const uint8_t* data) {
  ReturnValue_t result = verifyPacket(data, foundPacketLen);
-  if (result == mpsoc::CRC_FAILURE) {
+  if (result == MPSoCReturnValuesIF::CRC_FAILURE) {
    sif::warning << "PlocMPSoCHandler::handleCamCmdRpt: CRC failure" << std::endl;
  }
  SpacePacketReader packetReader(data, foundPacketLen);
@ -1218,11 +1247,15 @@ void PlocMpsocHandler::stepFailedReceived(ActionId_t actionId, uint8_t step,
  switch (actionId) {
    case supv::START_MPSOC: {
      sif::warning << "PlocMPSoCHandler::stepFailedReceived: Failed to start MPSoC" << std::endl;
      // This usually happens when the supervisor handler is in off mode
      powerState = PowerState::OFF;
      setMode(MODE_OFF);
      break;
    }
    case supv::SHUTDOWN_MPSOC: {
      triggerEvent(MPSOC_SHUTDOWN_FAILED);
      sif::warning << "PlocMPSoCHandler::stepFailedReceived: Failed to shutdown MPSoC" << std::endl;
      powerState = PowerState::OFF;
      break;
    }
    default:
@ -1230,7 +1263,6 @@ void PlocMpsocHandler::stepFailedReceived(ActionId_t actionId, uint8_t step,
                 << std::endl;
      break;
  }
  powerState = PowerState::SUPV_FAILED;
 }
 void PlocMpsocHandler::dataReceived(ActionId_t actionId, const uint8_t* data, uint32_t size) {
@ -1238,26 +1270,18 @@ void PlocMpsocHandler::dataReceived(ActionId_t actionId, const uint8_t* data, ui
 }
 void PlocMpsocHandler::completionSuccessfulReceived(ActionId_t actionId) {
-  if (actionId == supv::ACK_REPORT) {
+  if (actionId != supv::EXE_REPORT) {
-    // I seriously don't know why this happens..
+    sif::debug << "PlocMPSoCHandler::completionSuccessfulReceived: Did not expect this action "
-    //    sif::warning
+               << "ID" << std::endl;
    //        << "PlocMpsocHandler::completionSuccessfulReceived: Only received ACK report. Consider
    //        "
    //           "increasing the MPSoC boot timer."
    //        << std::endl;
  } else if (actionId != supv::EXE_REPORT) {
    sif::warning << "PlocMpsocHandler::completionSuccessfulReceived: Did not expect the action "
                 << "ID " << actionId << std::endl;
    return;
  }
  switch (powerState) {
-    case PowerState::PENDING_STARTUP: {
+    case PowerState::BOOTING: {
-      mpsocBootTransitionCd.resetTimer();
+      powerState = PowerState::ON;
      powerState = PowerState::DONE;
      break;
    }
-    case PowerState::PENDING_SHUTDOWN: {
+    case PowerState::SHUTDOWN: {
-      powerState = PowerState::DONE;
+      powerState = PowerState::OFF;
      break;
    }
    default: {
@ -1385,121 +1409,36 @@ void PlocMpsocHandler::disableExeReportReply() {
  info->command->second.expectedReplies = 0;
 }
 void PlocMpsocHandler::stopSpecialComHelper() {
  if (specialComHelper != nullptr) {
    specialComHelper->stopProcess();
  }
  specialComHelperExecuting = false;
 }
 bool PlocMpsocHandler::handleHwStartup() {
 #if OBSW_MPSOC_JTAG_BOOT == 1
  uartIsolatorSwitch.pullHigh();
  startupState = StartupState::WAIT_CYCLES;
  return true;
 #endif
  if (powerState == PowerState::IDLE) {
    if (skipSupvCommandingToOn) {
      powerState = PowerState::DONE;
    } else {
      if (supv::SUPV_ON) {
        commandActionHelper.commandAction(supervisorHandler, supv::START_MPSOC);
        supvTransitionCd.resetTimer();
        powerState = PowerState::PENDING_STARTUP;
      } else {
        triggerEvent(SUPV_NOT_ON, 1);
        // Set back to OFF for now, failing the transition.
        setMode(MODE_OFF);
      }
    }
  }
  if (powerState == PowerState::SUPV_FAILED) {
    setMode(MODE_OFF);
    powerState = PowerState::IDLE;
    return false;
  }
  if (powerState == PowerState::PENDING_STARTUP) {
    if (supvTransitionCd.hasTimedOut()) {
      // Process with transition nonetheless..
      triggerEvent(SUPV_REPLY_TIMEOUT);
      powerState = PowerState::DONE;
    } else {
      return false;
    }
  }
  if (powerState == PowerState::DONE) {
    if (mpsocBootTransitionCd.hasTimedOut()) {
      // Wait a bit for the MPSoC to fully boot.
      uartIsolatorSwitch.pullHigh();
      powerState = PowerState::IDLE;
    } else {
      return false;
    }
  }
  return true;
 }
 bool PlocMpsocHandler::handleHwShutdown() {
  stopSpecialComHelper();
  uartIsolatorSwitch.pullLow();
 #if OBSW_MPSOC_JTAG_BOOT == 1
  powerState = PowerState::DONE;
  return true;
 #endif
  if (powerState == PowerState::IDLE) {
    if (supv::SUPV_ON) {
      commandActionHelper.commandAction(supervisorHandler, supv::SHUTDOWN_MPSOC);
      supvTransitionCd.resetTimer();
      powerState = PowerState::PENDING_SHUTDOWN;
    } else {
      triggerEvent(SUPV_NOT_ON, 0);
      powerState = PowerState::DONE;
    }
  }
  if (powerState == PowerState::PENDING_SHUTDOWN) {
    if (supvTransitionCd.hasTimedOut()) {
      powerState = PowerState::DONE;
      // Process with transition nonetheless..
      triggerEvent(SUPV_REPLY_TIMEOUT);
      return true;
    } else {
      // Wait till power state is OFF.
      return false;
    }
  }
  return true;
 }
 void PlocMpsocHandler::handleActionCommandFailure(ActionId_t actionId) {
  switch (actionId) {
    case supv::ACK_REPORT:
    case supv::EXE_REPORT:
      break;
    default:
-      sif::warning << "PlocMPSoCHandler::handleActionCommandFailure: Did not expect the action ID "
+      sif::debug << "PlocMPSoCHandler::handleActionCommandFailure: Did not expect this action ID "
-                   << actionId << std::endl;
+                 << std::endl;
      return;
  }
  switch (powerState) {
-    case PowerState::PENDING_STARTUP: {
+    case PowerState::BOOTING: {
      sif::info << "PlocMPSoCHandler::handleActionCommandFailure: MPSoC boot command failed"
                << std::endl;
      // This is commonly the case when the MPSoC is already operational. Thus the power state is
      // set to on here
      powerState = PowerState::ON;
      break;
    }
-    case PowerState::PENDING_SHUTDOWN: {
+    case PowerState::SHUTDOWN: {
      // FDIR will intercept event and switch PLOC power off
      triggerEvent(MPSOC_SHUTDOWN_FAILED);
      sif::warning << "PlocMPSoCHandler::handleActionCommandFailure: Failed to shutdown MPSoC"
                   << std::endl;
      powerState = PowerState::OFF;
      break;
    }
    default:
      break;
  }
  powerState = PowerState::SUPV_FAILED;
  return;
 }
@ -1512,7 +1451,7 @@ LocalPoolDataSetBase* PlocMpsocHandler::getDataSetHandle(sid_t sid) {
 bool PlocMpsocHandler::dontCheckQueue() {
  // The TC and TMs need to be handled strictly sequentially, so while a command is pending,
-  // more specifically while replies are still expected, do not check the queue.
+  // more specifically while replies are still expected, do not check the queue.s
  return commandIsPending;
 }
@ -1527,33 +1466,3 @@ void PlocMpsocHandler::cmdDoneHandler(bool success, ReturnValue_t result) {
  }
  disableAllReplies();
 }
 ReturnValue_t PlocMpsocHandler::checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
                                                 uint32_t* msToReachTheMode) {
  if (commandedMode != MODE_OFF) {
    PoolReadGuard pg(&enablePl);
    if (pg.getReadResult() == returnvalue::OK) {
      if (enablePl.plUseAllowed.isValid() and not enablePl.plUseAllowed.value) {
        return NON_OP_STATE_OF_CHARGE;
      }
    }
  }
  return DeviceHandlerBase::checkModeCommand(commandedMode, commandedSubmode, msToReachTheMode);
 }
 ReturnValue_t PlocMpsocHandler::getParameter(uint8_t domainId, uint8_t uniqueId,
                                             ParameterWrapper* parameterWrapper,
                                             const ParameterWrapper* newValues,
                                             uint16_t startAtIndex) {
  if (uniqueId == mpsoc::ParamId::SKIP_SUPV_ON_COMMANDING) {
    uint8_t value = 0;
    newValues->getElement(&value);
    if (value > 1) {
      return HasParametersIF::INVALID_VALUE;
    }
    parameterWrapper->set(skipSupvCommandingToOn);
    return returnvalue::OK;
  }
  return DeviceHandlerBase::getParameter(domainId, uniqueId, parameterWrapper, newValues,
                                         startAtIndex);
 }
--- a/linux/payload/PlocMpsocHandler.h
+++ b/linux/payload/PlocMpsocHandler.h
@ -1,20 +1,21 @@
 #ifndef BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_
 #define BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_
-#include <linux/payload/PlocMpsocSpecialComHelperLegacy.h>
+#include <linux/payload/PlocMpsocSpecialComHelper.h>
 #include <linux/payload/mpsocRetvals.h>
 #include <linux/payload/plocMpsocHelpers.h>
 #include <linux/payload/plocSupvDefs.h>
-#include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
+
 #include <string>
 #include "fsfw/action/CommandActionHelper.h"
 #include "fsfw/action/CommandsActionsIF.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/tmtcservices/SourceSequenceCounter.h"
 #include "fsfw_hal/linux/gpio/Gpio.h"
 #include "fsfw_hal/linux/serial/SerialComIF.h"
 static constexpr bool DEBUG_MPSOC_COMMUNICATION = true;
 /**
 * @brief	This is the device handler for the MPSoC of the payload computer.
 *
@ -44,7 +45,7 @@ class PlocMpsocHandler : public DeviceHandlerBase, public CommandsActionsIF {
   * @param supervisorHandler   Object ID of the supervisor handler
   */
  PlocMpsocHandler(object_id_t objectId, object_id_t uartComIFid, CookieIF* comCookie,
-                   PlocMpsocSpecialComHelperLegacy* plocMPSoCHelper, Gpio uartIsolatorSwitch,
+                   PlocMpsocSpecialComHelper* plocMPSoCHelper, Gpio uartIsolatorSwitch,
                   object_id_t supervisorHandler);
  virtual ~PlocMpsocHandler();
  virtual ReturnValue_t initialize() override;
@ -102,17 +103,11 @@ class PlocMpsocHandler : public DeviceHandlerBase, public CommandsActionsIF {
  //! [EXPORT] : [COMMENT] Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and
  //! thus also to shutdown the supervisor.
  static const Event MPSOC_SHUTDOWN_FAILED = MAKE_EVENT(6, severity::HIGH);
  //! [EXPORT] : [COMMENT] SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for
  //! ON transition.
  static constexpr Event SUPV_NOT_ON = event::makeEvent(SUBSYSTEM_ID, 7, severity::LOW);
  static constexpr Event SUPV_REPLY_TIMEOUT = event::makeEvent(SUBSYSTEM_ID, 8, severity::LOW);
  static const uint16_t APID_MASK = 0x7FF;
  static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
  mpsoc::HkReport hkReport;
  Countdown mpsocBootTransitionCd = Countdown(6500);
  Countdown supvTransitionCd = Countdown(3000);
  MessageQueueIF* eventQueue = nullptr;
  MessageQueueIF* commandActionHelperQueue = nullptr;
@ -167,7 +162,7 @@ class PlocMpsocHandler : public DeviceHandlerBase, public CommandsActionsIF {
  SerialComIF* uartComIf = nullptr;
-  PlocMpsocSpecialComHelperLegacy* specialComHelper = nullptr;
+  PlocMpsocSpecialComHelper* specialComHelper = nullptr;
  Gpio uartIsolatorSwitch;
  object_id_t supervisorHandler = 0;
  CommandActionHelper commandActionHelper;
@ -182,7 +177,7 @@ class PlocMpsocHandler : public DeviceHandlerBase, public CommandsActionsIF {
  };
  TmMemReadReport tmMemReadReport;
-  Countdown cmdCountdown = Countdown(15000);
+  Countdown cmdCountdown = Countdown(10000);
  struct TelemetryBuffer {
    uint16_t length = 0;
@ -191,13 +186,12 @@ class PlocMpsocHandler : public DeviceHandlerBase, public CommandsActionsIF {
  size_t foundPacketLen = 0;
  TelemetryBuffer tmBuffer;
  uint32_t waitCycles = 0;
-  enum class StartupState { IDLE, HW_INIT, DONE } startupState = StartupState::IDLE;
+  enum class StartupState { IDLE, HW_INIT, WAIT_CYCLES, DONE } startupState = StartupState::IDLE;
-  enum class PowerState { IDLE, PENDING_STARTUP, PENDING_SHUTDOWN, SUPV_FAILED, DONE };
+  enum class PowerState { OFF, BOOTING, SHUTDOWN, ON };
-  PowerState powerState = PowerState::IDLE;
+  PowerState powerState = PowerState::OFF;
  uint8_t skipSupvCommandingToOn = false;
  /**
   * @brief   Handles events received from the PLOC MPSoC helper
@ -305,18 +299,8 @@ class PlocMpsocHandler : public DeviceHandlerBase, public CommandsActionsIF {
  ReturnValue_t prepareTcModeReplay();
  void cmdDoneHandler(bool success, ReturnValue_t result);
  bool handleHwStartup();
  bool handleHwShutdown();
  void stopSpecialComHelper();
  void handleActionCommandFailure(ActionId_t actionId);
  pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
  ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
                                 uint32_t* msToReachTheMode) override;
  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueId, ParameterWrapper* parameterWrapper,
                             const ParameterWrapper* newValues, uint16_t startAtIndex) override;
 };
 #endif /* BSP_Q7S_DEVICES_PLOC_PLOCMPSOCHANDLER_H_ */
--- a/linux/payload/PlocMpsocSpecialComHelper.cpp
+++ b/linux/payload/PlocMpsocSpecialComHelper.cpp
@ -6,21 +6,16 @@
 #include <filesystem>
 #include <fstream>
 #include "fsfw/serviceinterface/ServiceInterfacePrinter.h"
 #include "fsfw/serviceinterface/ServiceInterfaceStream.h"
 #include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
 #include "linux/payload/MpsocCommunication.h"
 #include "linux/payload/plocMpsocHelpers.h"
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/FilesystemHelper.h"
 #endif
 #include "mission/utility/Timestamp.h"
 using namespace ploc;
-PlocMpsocSpecialComHelper::PlocMpsocSpecialComHelper(object_id_t objectId,
+PlocMpsocSpecialComHelper::PlocMpsocSpecialComHelper(object_id_t objectId)
-                                                     MpsocCommunication& comInterface)
+    : SystemObject(objectId) {
    : SystemObject(objectId), comInterface(comInterface) {
  spParams.buf = commandBuffer;
  spParams.maxSize = sizeof(commandBuffer);
 }
@ -53,9 +48,9 @@ ReturnValue_t PlocMpsocSpecialComHelper::performOperation(uint8_t operationCode)
      case InternalState::FLASH_WRITE: {
        result = performFlashWrite();
        if (result == returnvalue::OK) {
-          triggerEvent(MPSOC_FLASH_WRITE_SUCCESSFUL, txSequenceCount.get());
+          triggerEvent(MPSOC_FLASH_WRITE_SUCCESSFUL, sequenceCount->get());
        } else {
-          triggerEvent(MPSOC_FLASH_WRITE_FAILED, txSequenceCount.get());
+          triggerEvent(MPSOC_FLASH_WRITE_FAILED, sequenceCount->get());
        }
        internalState = InternalState::IDLE;
        break;
@ -63,10 +58,9 @@ ReturnValue_t PlocMpsocSpecialComHelper::performOperation(uint8_t operationCode)
      case InternalState::FLASH_READ: {
        result = performFlashRead();
        if (result == returnvalue::OK) {
-          triggerEvent(MPSOC_FLASH_READ_SUCCESSFUL, txSequenceCount.get());
+          triggerEvent(MPSOC_FLASH_READ_SUCCESSFUL, sequenceCount->get());
        } else {
-          sif::printWarning("PLOC MPSoC Helper: Flash read failed with code %04x\n", result);
+          triggerEvent(MPSOC_FLASH_READ_FAILED, sequenceCount->get());
          triggerEvent(MPSOC_FLASH_READ_FAILED, txSequenceCount.get(), result);
        }
        internalState = InternalState::IDLE;
        break;
@ -78,12 +72,19 @@ ReturnValue_t PlocMpsocSpecialComHelper::performOperation(uint8_t operationCode)
  }
 }
-void PlocMpsocSpecialComHelper::setCommandSequenceCount(uint16_t sequenceCount_) {
+ReturnValue_t PlocMpsocSpecialComHelper::setComIF(DeviceCommunicationIF* communicationInterface_) {
-  txSequenceCount.set(sequenceCount_);
+  uartComIF = dynamic_cast<SerialComIF*>(communicationInterface_);
  if (uartComIF == nullptr) {
    sif::warning << "PlocMPSoCHelper::initialize: Invalid uart com if" << std::endl;
    return returnvalue::FAILED;
  }
  return returnvalue::OK;
 }
-uint16_t PlocMpsocSpecialComHelper::getCommandSequenceCount() const {
+void PlocMpsocSpecialComHelper::setComCookie(CookieIF* comCookie_) { comCookie = comCookie_; }
-  return txSequenceCount.get();
+
 void PlocMpsocSpecialComHelper::setSequenceCount(SourceSequenceCounter* sequenceCount_) {
  sequenceCount = sequenceCount_;
 }
 ReturnValue_t PlocMpsocSpecialComHelper::startFlashWrite(std::string obcFile,
@ -116,8 +117,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::startFlashRead(std::string obcFile, std
 void PlocMpsocSpecialComHelper::resetHelper() {
  spParams.buf = commandBuffer;
  terminate = false;
-  auto& helper = comInterface.getComHelper();
+  uartComIF->flushUartRxBuffer(comCookie);
  helper.flushUartRxBuffer();
 }
 void PlocMpsocSpecialComHelper::stopProcess() { terminate = true; }
@ -155,7 +155,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashWrite() {
    file.read(reinterpret_cast<char*>(fileBuf.data()), dataLength);
    bytesRead += dataLength;
    remainingSize -= dataLength;
-    mpsoc::TcFlashWrite tc(spParams, txSequenceCount);
+    mpsoc::TcFlashWrite tc(spParams, *sequenceCount);
    result = tc.setPayload(fileBuf.data(), dataLength);
    if (result != returnvalue::OK) {
      return result;
@ -164,7 +164,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashWrite() {
    if (result != returnvalue::OK) {
      return result;
    }
-    txSequenceCount.increment();
+    (*sequenceCount)++;
    result = handlePacketTransmissionNoReply(tc);
    if (result != returnvalue::OK) {
      return result;
@ -179,12 +179,8 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashWrite() {
 ReturnValue_t PlocMpsocSpecialComHelper::performFlashRead() {
  std::error_code e;
-  if (std::filesystem::exists(flashReadAndWrite.obcFile)) {
+  std::ofstream ofile(flashReadAndWrite.obcFile, std::ios::trunc | std::ios::binary);
-    // Truncate the file first.
+  if (ofile.bad()) {
    std::ofstream ofile(flashReadAndWrite.obcFile, std::ios::binary | std::ios::trunc);
  }
  std::ofstream ofile(flashReadAndWrite.obcFile, std::ios::binary | std::ios::app);
  if (ofile.bad() or not ofile.is_open()) {
    return returnvalue::FAILED;
  }
  ReturnValue_t result = flashfopen(mpsoc::FileAccessModes::READ);
@ -207,7 +203,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashRead() {
      std::filesystem::remove(flashReadAndWrite.obcFile, e);
      return FILE_READ_ERROR;
    }
-    mpsoc::TcFlashRead flashReadRequest(spParams, txSequenceCount);
+    mpsoc::TcFlashRead flashReadRequest(spParams, *sequenceCount);
    result = flashReadRequest.setPayload(nextReadSize);
    if (result != returnvalue::OK) {
      std::filesystem::remove(flashReadAndWrite.obcFile, e);
@ -218,7 +214,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashRead() {
      std::filesystem::remove(flashReadAndWrite.obcFile, e);
      return result;
    }
-    txSequenceCount.increment();
+    (*sequenceCount)++;
    result = handlePacketTransmissionFlashRead(flashReadRequest, ofile, nextReadSize);
    if (result != returnvalue::OK) {
      std::filesystem::remove(flashReadAndWrite.obcFile, e);
@ -235,7 +231,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::performFlashRead() {
 ReturnValue_t PlocMpsocSpecialComHelper::flashfopen(uint8_t mode) {
  spParams.buf = commandBuffer;
-  mpsoc::TcFlashFopen flashFopen(spParams, txSequenceCount);
+  mpsoc::FlashFopen flashFopen(spParams, *sequenceCount);
  ReturnValue_t result = flashFopen.setPayload(flashReadAndWrite.mpsocFile, mode);
  if (result != returnvalue::OK) {
    return result;
@ -244,7 +240,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::flashfopen(uint8_t mode) {
  if (result != returnvalue::OK) {
    return result;
  }
-  txSequenceCount.increment();
+  (*sequenceCount)++;
  result = handlePacketTransmissionNoReply(flashFopen);
  if (result != returnvalue::OK) {
    return result;
@ -254,12 +250,12 @@ ReturnValue_t PlocMpsocSpecialComHelper::flashfopen(uint8_t mode) {
 ReturnValue_t PlocMpsocSpecialComHelper::flashfclose() {
  spParams.buf = commandBuffer;
-  mpsoc::TcFlashFclose flashFclose(spParams, txSequenceCount);
+  mpsoc::FlashFclose flashFclose(spParams, *sequenceCount);
  ReturnValue_t result = flashFclose.finishPacket();
  if (result != returnvalue::OK) {
    return result;
  }
-  txSequenceCount.increment();
+  (*sequenceCount)++;
  result = handlePacketTransmissionNoReply(flashFclose);
  if (result != returnvalue::OK) {
    return result;
@ -282,7 +278,6 @@ ReturnValue_t PlocMpsocSpecialComHelper::handlePacketTransmissionFlashRead(mpsoc
  if (result != returnvalue::OK) {
    return result;
  }
  auto& spReader = comInterface.getSpReader();
  // We have the nominal case where the flash read report appears first, or the case where we
  // get an EXE failure immediately.
@ -293,7 +288,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::handlePacketTransmissionFlashRead(mpsoc
    }
    return handleExe();
  } else if (spReader.getApid() == mpsoc::apid::EXE_FAILURE) {
-    handleExeFailure(spReader);
+    handleExeFailure();
  } else {
    triggerEvent(MPSOC_EXE_INVALID_APID, spReader.getApid(), static_cast<uint32_t>(internalState));
    sif::warning << "PLOC MPSoC: Expected execution report "
@ -316,8 +311,8 @@ ReturnValue_t PlocMpsocSpecialComHelper::handlePacketTransmissionNoReply(ploc::S
 }
 ReturnValue_t PlocMpsocSpecialComHelper::sendCommand(ploc::SpTcBase& tc) {
-  ReturnValue_t result = comInterface.send(tc.getFullPacket(), tc.getFullPacketLen());
+  ReturnValue_t result = returnvalue::OK;
-  mpsoc::printTxPacket(tc);
+  result = uartComIF->sendMessage(comCookie, tc.getFullPacket(), tc.getFullPacketLen());
  if (result != returnvalue::OK) {
    sif::warning << "PlocMPSoCHelper::sendCommand: Failed to send command" << std::endl;
    triggerEvent(MPSOC_SENDING_COMMAND_FAILED, result, static_cast<uint32_t>(internalState));
@ -336,8 +331,6 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleAck() {
  if (result != returnvalue::OK) {
    return result;
  }
  const auto& spReader = comInterface.getSpReader();
  uint16_t apid = spReader.getApid();
  if (apid != mpsoc::apid::ACK_SUCCESS) {
    handleAckApidFailure(spReader);
@ -346,7 +339,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleAck() {
  return returnvalue::OK;
 }
-void PlocMpsocSpecialComHelper::handleAckApidFailure(const SpacePacketReader& reader) {
+void PlocMpsocSpecialComHelper::handleAckApidFailure(const ploc::SpTmReader& reader) {
  uint16_t apid = reader.getApid();
  if (apid == mpsoc::apid::ACK_FAILURE) {
    uint16_t status = mpsoc::getStatusFromRawData(reader.getFullData());
@ -370,10 +363,9 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleExe() {
  if (result != returnvalue::OK) {
    return result;
  }
  const auto& spReader = comInterface.getSpReader();
  uint16_t apid = spReader.getApid();
  if (apid == mpsoc::apid::EXE_FAILURE) {
-    handleExeFailure(spReader);
+    handleExeFailure();
    return returnvalue::FAILED;
  } else if (apid != mpsoc::apid::EXE_SUCCESS) {
    triggerEvent(MPSOC_EXE_INVALID_APID, apid, static_cast<uint32_t>(internalState));
@ -383,7 +375,7 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleExe() {
  return returnvalue::OK;
 }
-void PlocMpsocSpecialComHelper::handleExeFailure(const SpacePacketReader& spReader) {
+void PlocMpsocSpecialComHelper::handleExeFailure() {
  uint16_t status = mpsoc::getStatusFromRawData(spReader.getFullData());
  sif::warning << "PLOC MPSoC EXE Failure: " << mpsoc::getStatusString(status) << std::endl;
  triggerEvent(MPSOC_EXE_FAILURE_REPORT, static_cast<uint32_t>(internalState));
@ -392,32 +384,46 @@ void PlocMpsocSpecialComHelper::handleExeFailure(const SpacePacketReader& spRead
 ReturnValue_t PlocMpsocSpecialComHelper::handleTmReception() {
  ReturnValue_t result = returnvalue::OK;
  tmCountdown.resetTimer();
  size_t readBytes = 0;
  size_t currentBytes = 0;
  uint32_t usleepDelay = 5;
  size_t fullPacketLen = 0;
  while (true) {
    if (tmCountdown.hasTimedOut()) {
      triggerEvent(MPSOC_READ_TIMEOUT, tmCountdown.getTimeoutMs());
      return returnvalue::FAILED;
    }
-    result = tryReceiveNextReply();
+    result = receive(tmBuf.data() + readBytes, 6, &currentBytes);
    if (result == MpsocCommunication::PACKET_RECEIVED) {
      // Need to convert this, we are faking a synchronous API here.
      result = returnvalue::OK;
      break;
    }
    if (result != returnvalue::OK) {
      if (result == MpsocCommunication::FAULTY_PACKET_SIZE) {
        sif::printWarning("PLOC MPSoC Helper: retrieving next reply failed: faulty packet size\n");
      } else if (result == MpsocCommunication::CRC_CHECK_FAILED) {
        sif::printWarning("PLOC MPSoC Helper: retrieving next reply failed: CRC check failed\n");
      }
      sif::printWarning("PLOC MPSoC Helper: retrieving next reply failed with code %d\n", result);
      return result;
    }
    spReader.setReadOnlyData(tmBuf.data(), tmBuf.size());
    fullPacketLen = spReader.getFullPacketLen();
    readBytes += currentBytes;
    if (readBytes == 6) {
      break;
    }
    usleep(usleepDelay);
    if (usleepDelay < 200000) {
      usleepDelay *= 4;
    }
  }
  while (true) {
    if (tmCountdown.hasTimedOut()) {
      triggerEvent(MPSOC_READ_TIMEOUT, tmCountdown.getTimeoutMs());
      return returnvalue::FAILED;
    }
    result = receive(tmBuf.data() + readBytes, fullPacketLen - readBytes, &currentBytes);
    readBytes += currentBytes;
    if (fullPacketLen == readBytes) {
      break;
    }
    usleep(usleepDelay);
    if (usleepDelay < 200000) {
      usleepDelay *= 4;
    }
  }
  // arrayprinter::print(tmBuf.data(), readBytes);
  return result;
 }
@ -427,7 +433,6 @@ ReturnValue_t PlocMpsocSpecialComHelper::handleFlashReadReply(std::ofstream& ofi
  if (result != returnvalue::OK) {
    return result;
  }
  auto& spReader = comInterface.getSpReader();
  uint16_t apid = spReader.getApid();
  if (apid != mpsoc::apid::TM_FLASH_READ_REPORT) {
    triggerEvent(MPSOC_FLASH_READ_PACKET_ERROR, FlashReadErrorType::FLASH_READ_APID_ERROR);
@ -493,25 +498,47 @@ ReturnValue_t PlocMpsocSpecialComHelper::startFlashReadOrWriteBase(std::string o
 }
 ReturnValue_t PlocMpsocSpecialComHelper::checkReceivedTm() {
  const auto& spReader = comInterface.getSpReader();
  ReturnValue_t result = spReader.checkSize();
  if (result != returnvalue::OK) {
    sif::error << "PLOC MPSoC: Size check on received TM failed" << std::endl;
    triggerEvent(MPSOC_TM_SIZE_ERROR);
    return result;
  }
-  rxSequenceCount = spReader.getSequenceCount();
+  spReader.checkCrc();
-  mpsoc::printRxPacket(spReader);
+  if (result != returnvalue::OK) {
    sif::warning << "PLOC MPSoC: CRC check failed" << std::endl;
    triggerEvent(MPSOC_TM_CRC_MISSMATCH, *sequenceCount);
    return result;
  }
  uint16_t recvSeqCnt = spReader.getSequenceCount();
  if (recvSeqCnt != *sequenceCount) {
    triggerEvent(MPSOC_HELPER_SEQ_CNT_MISMATCH, *sequenceCount, recvSeqCnt);
    *sequenceCount = recvSeqCnt;
  }
  // This sequence count ping pong does not make any sense but it is how the MPSoC expects it.
  (*sequenceCount)++;
  return returnvalue::OK;
 }
-ReturnValue_t PlocMpsocSpecialComHelper::tryReceiveNextReply() {
+ReturnValue_t PlocMpsocSpecialComHelper::receive(uint8_t* data, size_t requestBytes,
                                                 size_t* readBytes) {
  ReturnValue_t result = returnvalue::OK;
-  result = comInterface.readSerialInterface();
+  uint8_t* buffer = nullptr;
  result = uartComIF->requestReceiveMessage(comCookie, requestBytes);
  if (result != returnvalue::OK) {
    sif::warning << "PlocMPSoCHelper::receive: Failed to request reply" << std::endl;
    triggerEvent(MPSOC_HELPER_REQUESTING_REPLY_FAILED, result,
                 static_cast<uint32_t>(static_cast<uint32_t>(internalState)));
    return returnvalue::FAILED;
  }
-  return comInterface.parseAndRetrieveNextPacket();
+  result = uartComIF->readReceivedMessage(comCookie, &buffer, readBytes);
  if (result != returnvalue::OK) {
    sif::warning << "PlocMPSoCHelper::receive: Failed to read received message" << std::endl;
    triggerEvent(MPSOC_HELPER_READING_REPLY_FAILED, result, static_cast<uint32_t>(internalState));
    return returnvalue::FAILED;
  }
  if (*readBytes > 0) {
    std::memcpy(data, buffer, *readBytes);
  }
  return result;
 }
--- a/linux/payload/PlocMpsocSpecialComHelper.h
+++ b/linux/payload/PlocMpsocSpecialComHelper.h
@ -6,13 +6,14 @@
 #include <string>
 #include "OBSWConfig.h"
 #include "fsfw/devicehandlers/CookieIF.h"
 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/osal/linux/BinarySemaphore.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
 #include "fsfw/tmtcservices/SourceSequenceCounter.h"
-#include "linux/payload/MpsocCommunication.h"
+#include "fsfw_hal/linux/serial/SerialComIF.h"
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/SdCardManager.h"
 #endif
@ -82,12 +83,15 @@ class PlocMpsocSpecialComHelper : public SystemObject, public ExecutableObjectIF
    FLASH_READ_READLEN_ERROR = 2
  };
-  PlocMpsocSpecialComHelper(object_id_t objectId, MpsocCommunication& comInterface);
+  PlocMpsocSpecialComHelper(object_id_t objectId);
  virtual ~PlocMpsocSpecialComHelper();
  ReturnValue_t initialize() override;
  ReturnValue_t performOperation(uint8_t operationCode = 0) override;
  ReturnValue_t setComIF(DeviceCommunicationIF* communicationInterface_);
  void setComCookie(CookieIF* comCookie_);
  /**
   * @brief   Starts flash write sequence
   *
@ -114,8 +118,7 @@ class PlocMpsocSpecialComHelper : public SystemObject, public ExecutableObjectIF
  /**
   * @brief   Sets the sequence count object responsible for the sequence count handling
   */
-  void setCommandSequenceCount(uint16_t sequenceCount_);
+  void setSequenceCount(SourceSequenceCounter* sequenceCount_);
  uint16_t getCommandSequenceCount() const;
 private:
  static const uint8_t INTERFACE_ID = CLASS_ID::PLOC_MPSOC_HELPER;
@ -166,14 +169,12 @@ class PlocMpsocSpecialComHelper : public SystemObject, public ExecutableObjectIF
   * Communication interface of MPSoC responsible for low level access. Must be set by the
   * MPSoC Handler.
   */
-  // SerialComIF* uartComIF = nullptr;
+  SerialComIF* uartComIF = nullptr;
  // Communication cookie. Must be set by the MPSoC Handler
-  // CookieIF* comCookie = nullptr;
+  CookieIF* comCookie = nullptr;
  MpsocCommunication& comInterface;
  // Sequence count, must be set by Ploc MPSoC Handler
-  // ploc::SpTmReader spReader;
+  SourceSequenceCounter* sequenceCount = nullptr;
-  uint16_t rxSequenceCount = 0;
+  ploc::SpTmReader spReader;
  SourceSequenceCounter txSequenceCount = 0;
  void resetHelper();
  ReturnValue_t performFlashWrite();
@ -185,13 +186,13 @@ class PlocMpsocSpecialComHelper : public SystemObject, public ExecutableObjectIF
                                                  size_t expectedReadLen);
  ReturnValue_t handleFlashReadReply(std::ofstream& ofile, size_t expectedReadLen);
  ReturnValue_t sendCommand(ploc::SpTcBase& tc);
-  ReturnValue_t tryReceiveNextReply();
+  ReturnValue_t receive(uint8_t* data, size_t requestBytes, size_t* readBytes);
  ReturnValue_t handleAck();
  ReturnValue_t handleExe();
  ReturnValue_t startFlashReadOrWriteBase(std::string obcFile, std::string mpsocFile);
  ReturnValue_t fileCheck(std::string obcFile);
-  void handleAckApidFailure(const SpacePacketReader& reader);
+  void handleAckApidFailure(const ploc::SpTmReader& reader);
-  void handleExeFailure(const SpacePacketReader& reader);
+  void handleExeFailure();
  ReturnValue_t handleTmReception();
  ReturnValue_t checkReceivedTm();
 };
--- a/linux/payload/PlocSupervisorHandler.cpp
+++ b/linux/payload/PlocSupervisorHandler.cpp
@ -27,7 +27,7 @@ PlocSupervisorHandler::PlocSupervisorHandler(object_id_t objectId, CookieIF* com
      hkset(this),
      bootStatusReport(this),
      latchupStatusReport(this),
-      countersReport(this),
+      loggingReport(this),
      adcReport(this),
      powerSwitch(powerSwitch),
      uartManager(supvHelper) {
@ -59,19 +59,6 @@ ReturnValue_t PlocSupervisorHandler::initialize() {
 }
 void PlocSupervisorHandler::performOperationHook() {
  if (normalCommandIsPending and normalCmdCd.hasTimedOut()) {
    // Event, FDIR, printout? Leads to spam though and normally should not happen..
    normalCommandIsPending = false;
  }
  if (commandIsPending and cmdCd.hasTimedOut()) {
    // Event, FDIR, printout? Leads to spam though and normally should not happen..
    commandIsPending = false;
    //    if(iter->second.sendReplyTo != NO_COMMANDER) {
    //      actionHelper.finish(true, iter->second.sendReplyTo, iter->first, returnvalue::OK);
    //    }
    disableAllReplies();
  }
  EventMessage event;
  for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == returnvalue::OK;
       result = eventQueue->receiveMessage(&event)) {
@ -169,7 +156,6 @@ void PlocSupervisorHandler::doStartUp() {
  }
  if (startupState == StartupState::ON) {
    hkset.setReportingEnabled(true);
    supv::SUPV_ON = true;
    setMode(_MODE_TO_ON);
  }
 }
@ -183,16 +169,12 @@ void PlocSupervisorHandler::doShutDown() {
  nextReplyId = supv::NONE;
  uartManager.stop();
  uartIsolatorSwitch.pullLow();
  disableAllReplies();
  supv::SUPV_ON = false;
  startupState = StartupState::OFF;
 }
 ReturnValue_t PlocSupervisorHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
-  if (not normalCommandIsPending) {
+  if (not commandIsExecuting(GET_HK_REPORT)) {
    *id = GET_HK_REPORT;
    normalCommandIsPending = true;
    normalCmdCd.resetTimer();
    return buildCommandFromCommand(*id, nullptr, 0);
  }
  return NOTHING_TO_SEND;
@ -220,13 +202,11 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
      break;
    }
    case START_MPSOC: {
      sif::info << "PLOC SUPV: Starting MPSoC" << std::endl;
      prepareEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::START_MPSOC));
      result = returnvalue::OK;
      break;
    }
    case SHUTDOWN_MPSOC: {
      sif::info << "PLOC SUPV: Shutting down MPSoC" << std::endl;
      prepareEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::SHUTDOWN_MPSOC));
      result = returnvalue::OK;
      break;
@ -237,7 +217,6 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
      break;
    }
    case RESET_MPSOC: {
      sif::info << "PLOC SUPV: Resetting MPSoC" << std::endl;
      prepareEmptyCmd(Apid::BOOT_MAN, static_cast<uint8_t>(tc::BootManId::RESET_MPSOC));
      result = returnvalue::OK;
      break;
@ -288,7 +267,8 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
      break;
    }
    case SET_GPIO: {
-      result = prepareSetGpioCmd(commandData, commandDataLen);
+      prepareSetGpioCmd(commandData);
      result = returnvalue::OK;
      break;
    }
    case FACTORY_RESET: {
@ -296,7 +276,8 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
      break;
    }
    case READ_GPIO: {
-      result = prepareReadGpioCmd(commandData, commandDataLen);
+      prepareReadGpioCmd(commandData);
      result = returnvalue::OK;
      break;
    }
    case SET_SHUTDOWN_TIMEOUT: {
@ -333,25 +314,91 @@ ReturnValue_t PlocSupervisorHandler::buildCommandFromCommand(DeviceCommandId_t d
      result = prepareWipeMramCmd(commandData);
      break;
    }
-    case REQUEST_ADC_REPORT: {
+      //    case ENABLE_NVMS: {
-      prepareEmptyCmd(Apid::ADC_MON, static_cast<uint8_t>(tc::AdcMonId::REQUEST_ADC_SAMPLE));
+      //      result = prepareEnableNvmsCommand(commandData);
-      result = returnvalue::OK;
+      //      break;
-      break;
+      //    }
-    }
+      //    case RESTART_SUPERVISOR: {
-    case REQUEST_LOGGING_COUNTERS: {
+      //      prepareEmptyCmd(APID_RESTART_SUPERVISOR);
-      prepareEmptyCmd(Apid::DATA_LOGGER,
+      //      result = returnvalue::OK;
-                      static_cast<uint8_t>(tc::DataLoggerServiceId::REQUEST_COUNTERS));
+      //      break;
-      result = returnvalue::OK;
+      //    }
-      break;
+      // Removed command
-    }
+      //    case START_MPSOC_QUIET: {
      //      prepareEmptyCmd(APID_START_MPSOC_QUIET);
      //      result = returnvalue::OK;
      //      break;
      //    }
      //    case ENABLE_AUTO_TM: {
      //      EnableAutoTm packet(spParams);
      //      result = packet.buildPacket();
      //      if (result != returnvalue::OK) {
      //        break;
      //      }
      //      finishTcPrep(packet.getFullPacketLen());
      //      break;
      //    }
      //    case DISABLE_AUTO_TM: {
      //      DisableAutoTm packet(spParams);
      //      result = packet.buildPacket();
      //      if (result != returnvalue::OK) {
      //        break;
      //      }
      //      finishTcPrep(packet.getFullPacketLen());
      //      break;
      //    }
      //    case LOGGING_REQUEST_COUNTERS: {
      //      RequestLoggingData packet(spParams);
      //      result = packet.buildPacket(RequestLoggingData::Sa::REQUEST_COUNTERS);
      //      if (result != returnvalue::OK) {
      //        break;
      //      }
      //      finishTcPrep(packet.getFullPacketLen());
      //      break;
      //    }
      //    case LOGGING_CLEAR_COUNTERS: {
      //      RequestLoggingData packet(spParams);
      //      result = packet.buildPacket(RequestLoggingData::Sa::CLEAR_COUNTERS);
      //      if (result != returnvalue::OK) {
      //        break;
      //      }
      //      finishTcPrep(packet.getFullPacketLen());
      //      break;
      //    }
      //    case LOGGING_SET_TOPIC: {
      //      if (commandData == nullptr or commandDataLen == 0) {
      //        return HasActionsIF::INVALID_PARAMETERS;
      //      }
      //      uint8_t tpc = *(commandData);
      //      RequestLoggingData packet(spParams);
      //      result = packet.buildPacket(RequestLoggingData::Sa::SET_LOGGING_TOPIC, tpc);
      //      if (result != returnvalue::OK) {
      //        break;
      //      }
      //      finishTcPrep(packet.getFullPacketLen());
      //      break;
      //    }
      // I think this is disabled right now according to the TC excel table
      //    case COPY_ADC_DATA_TO_MRAM: {
      //      prepareEmptyCmd(APID_COPY_ADC_DATA_TO_MRAM);
      //      result = returnvalue::OK;
      //      break;
      //    }
      //    case REQUEST_ADC_REPORT: {
      //      prepareEmptyCmd(APID_REQUEST_ADC_REPORT);
      //      result = returnvalue::OK;
      //      break;
      //    }
      //    case FIRST_MRAM_DUMP:
      //    case CONSECUTIVE_MRAM_DUMP:
      //      result = prepareDumpMramCmd(commandData);
      //      break;
    default:
      sif::debug << "PlocSupervisorHandler::buildCommandFromCommand: Command not implemented"
                 << std::endl;
      result = DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
      break;
  }
  commandIsPending = true;
  cmdCd.resetTimer();
  return result;
 }
@ -383,8 +430,6 @@ void PlocSupervisorHandler::fillCommandAndReplyMap() {
  insertInCommandMap(SET_ADC_THRESHOLD);
  insertInCommandMap(SET_ADC_WINDOW_AND_STRIDE);
  insertInCommandMap(RESET_PL);
  insertInCommandMap(REQUEST_ADC_REPORT);
  insertInCommandMap(REQUEST_LOGGING_COUNTERS);
  // ACK replies, use countdown for them
  insertInReplyMap(ACK_REPORT, 0, nullptr, SIZE_ACK_REPORT, false, &acknowledgementReportTimeout);
@ -395,7 +440,7 @@ void PlocSupervisorHandler::fillCommandAndReplyMap() {
  insertInReplyMap(HK_REPORT, 3, &hkset);
  insertInReplyMap(BOOT_STATUS_REPORT, 3, &bootStatusReport, SIZE_BOOT_STATUS_REPORT);
  insertInReplyMap(LATCHUP_REPORT, 3, &latchupStatusReport, SIZE_LATCHUP_STATUS_REPORT);
-  insertInReplyMap(COUNTERS_REPORT, 3, &countersReport, SIZE_COUNTERS_REPORT);
+  insertInReplyMap(LOGGING_REPORT, 3, &loggingReport, SIZE_LOGGING_REPORT);
  insertInReplyMap(ADC_REPORT, 3, &adcReport, SIZE_ADC_REPORT);
 }
@ -437,13 +482,13 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite
      }
      break;
    }
-    case REQUEST_LOGGING_COUNTERS: {
+    case LOGGING_REQUEST_COUNTERS: {
      enabledReplies = 3;
      result =
-          DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, COUNTERS_REPORT);
+          DeviceHandlerBase::enableReplyInReplyMap(command, enabledReplies, true, LOGGING_REPORT);
      if (result != returnvalue::OK) {
        sif::debug << "PlocSupervisorHandler::enableReplyInReplyMap: Reply with id "
-                   << COUNTERS_REPORT << " not in replyMap" << std::endl;
+                   << LOGGING_REPORT << " not in replyMap" << std::endl;
      }
      break;
    }
@ -499,17 +544,23 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite
    case SET_ADC_ENABLED_CHANNELS:
    case SET_ADC_WINDOW_AND_STRIDE:
    case SET_ADC_THRESHOLD:
    // case COPY_ADC_DATA_TO_MRAM:
    case RUN_AUTO_EM_TESTS:
    case WIPE_MRAM:
    case SET_GPIO:
    case FACTORY_RESET:
    case READ_GPIO:
    // case RESTART_SUPERVISOR:
    case DISABLE_PERIOIC_HK_TRANSMISSION:
    // case START_MPSOC_QUIET:
    case SET_SHUTDOWN_TIMEOUT:
    case FACTORY_FLASH:
    case ENABLE_AUTO_TM:
    case DISABLE_AUTO_TM:
    // case LOGGING_CLEAR_COUNTERS:
    // case LOGGING_SET_TOPIC:
    case RESET_PL:
      // case ENABLE_NVMS:
      enabledReplies = 2;
      break;
    default:
@ -541,12 +592,19 @@ ReturnValue_t PlocSupervisorHandler::enableReplyInReplyMap(DeviceCommandMap::ite
 ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t remainingSize,
                                                  DeviceCommandId_t* foundId, size_t* foundLen) {
  using namespace supv;
  // TODO: Is this still required?
  //  if (nextReplyId == FIRST_MRAM_DUMP) {
  //    *foundId = FIRST_MRAM_DUMP;
  //    return parseMramPackets(start, remainingSize, foundLen);
  //  } else if (nextReplyId == CONSECUTIVE_MRAM_DUMP) {
  //    *foundId = CONSECUTIVE_MRAM_DUMP;
  //    return parseMramPackets(start, remainingSize, foundLen);
  //  }
  tmReader.setData(start, remainingSize);
  // sif::debug << "PlocSupervisorHandler::scanForReply: Received Packet" << std::endl;
  // arrayprinter::print(start, remainingSize);
  uint16_t apid = tmReader.getModuleApid();
  if (DEBUG_PLOC_SUPV) {
    handlePacketPrint();
  }
  switch (apid) {
    case (Apid::TMTC_MAN): {
@ -568,9 +626,6 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t r
    }
    case (Apid::HK): {
      if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::HkId::REPORT)) {
        normalCommandIsPending = false;
        // Yeah apparently this is needed??
        disableCommand(GET_HK_REPORT);
        *foundLen = tmReader.getFullPacketLen();
        *foundId = ReplyId::HK_REPORT;
        return OK;
@ -589,14 +644,6 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t r
      }
      break;
    }
    case (Apid::ADC_MON): {
      if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::AdcMonId::ADC_REPORT)) {
        *foundLen = tmReader.getFullPacketLen();
        *foundId = ReplyId::ADC_REPORT;
        return OK;
      }
      break;
    }
    case (Apid::MEM_MAN): {
      if (tmReader.getServiceId() ==
          static_cast<uint8_t>(supv::tm::MemManId::UPDATE_STATUS_REPORT)) {
@ -604,15 +651,6 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t r
        *foundId = ReplyId::UPDATE_STATUS_REPORT;
        return OK;
      }
      break;
    }
    case (Apid::DATA_LOGGER): {
      if (tmReader.getServiceId() ==
          static_cast<uint8_t>(supv::tm::DataLoggerId::COUNTERS_REPORT)) {
        *foundLen = tmReader.getFullPacketLen();
        *foundId = ReplyId::COUNTERS_REPORT;
        return OK;
      }
    }
  }
  handleBadApidServiceCombination(SUPV_UNKNOWN_TM, apid, tmReader.getServiceId());
@ -620,58 +658,6 @@ ReturnValue_t PlocSupervisorHandler::scanForReply(const uint8_t* start, size_t r
  return INVALID_DATA;
 }
 void PlocSupervisorHandler::handlePacketPrint() {
  if (tmReader.getModuleApid() == Apid::TMTC_MAN) {
    if ((tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::ACK)) or
        (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::NAK))) {
      AcknowledgmentReport ack(tmReader);
      ReturnValue_t result = ack.parse();
      if (result != returnvalue::OK) {
        sif::warning << "PlocSupervisorHandler: Parsing ACK failed" << std::endl;
      }
      if (REDUCE_NORMAL_MODE_PRINTOUT and ack.getRefModuleApid() == (uint8_t)supv::Apid::HK and
          ack.getRefServiceId() == (uint8_t)supv::tc::HkId::GET_REPORT) {
        return;
      }
      const char* printStr = "???";
      if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::ACK)) {
        printStr = "ACK";
      } else if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::NAK)) {
        printStr = "NAK";
      }
      sif::debug << "PlocSupervisorHandler: RECV " << printStr << " for APID Module ID "
                 << (int)ack.getRefModuleApid() << " Service ID " << (int)ack.getRefServiceId()
                 << " Seq Count " << ack.getRefSequenceCount() << std::endl;
      return;
    } else if ((tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_ACK)) or
               (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK))) {
      ExecutionReport exe(tmReader);
      ReturnValue_t result = exe.parse();
      if (result != returnvalue::OK) {
        sif::warning << "PlocSupervisorHandler: Parsing EXE failed" << std::endl;
      }
      const char* printStr = "???";
      if (REDUCE_NORMAL_MODE_PRINTOUT and exe.getRefModuleApid() == (uint8_t)supv::Apid::HK and
          exe.getRefServiceId() == (uint8_t)supv::tc::HkId::GET_REPORT) {
        return;
      }
      if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_ACK)) {
        printStr = "ACK EXE";
      } else if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK)) {
        printStr = "NAK EXE";
      }
      sif::debug << "PlocSupervisorHandler: RECV " << printStr << " for APID Module ID "
                 << (int)exe.getRefModuleApid() << " Service ID " << (int)exe.getRefServiceId()
                 << " Seq Count " << exe.getRefSequenceCount() << std::endl;
      return;
    }
  }
  sif::debug << "PlocSupervisorHandler: RECV PACKET Size " << tmReader.getFullPacketLen()
             << " Module APID " << (int)tmReader.getModuleApid() << " Service ID "
             << (int)tmReader.getServiceId() << std::endl;
 }
 ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
                                                          const uint8_t* packet) {
  using namespace supv;
@ -690,22 +676,12 @@ ReturnValue_t PlocSupervisorHandler::interpretDeviceReply(DeviceCommandId_t id,
      result = handleBootStatusReport(packet);
      break;
    }
    case (COUNTERS_REPORT): {
      result = genericHandleTm("COUNTERS", packet, countersReport);
 #if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
      countersReport.printSet();
 #endif
      break;
    }
    case (LATCHUP_REPORT): {
      result = handleLatchupStatusReport(packet);
      break;
    }
    case (ADC_REPORT): {
-      result = genericHandleTm("ADC", packet, adcReport);
+      result = handleAdcReport(packet);
 #if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
      adcReport.printSet();
 #endif
      break;
    }
    case (EXE_REPORT): {
@ -770,8 +746,13 @@ ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool
  localDataPoolMap.emplace(supv::LATCHUP_RPT_TIME_YEAR, new PoolEntry<uint8_t>({0}));
  localDataPoolMap.emplace(supv::LATCHUP_RPT_IS_SET, new PoolEntry<uint8_t>({0}));
-  localDataPoolMap.emplace(supv::SIGNATURE, new PoolEntry<uint32_t>());
+  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_0, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNTS, &latchupCounters);
+  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_1, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_2, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_3, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_4, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_5, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::LATCHUP_HAPPENED_CNT_6, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::ADC_DEVIATION_TRIGGERS_CNT, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::TC_RECEIVED_CNT, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::TM_AVAILABLE_CNT, new PoolEntry<uint32_t>({0}));
@ -780,22 +761,41 @@ ReturnValue_t PlocSupervisorHandler::initializeLocalDataPool(localpool::DataPool
  localDataPoolMap.emplace(supv::MPSOC_BOOT_FAILED_ATTEMPTS, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::MPSOC_POWER_UP, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::MPSOC_UPDATES, new PoolEntry<uint32_t>({0}));
-  localDataPoolMap.emplace(supv::MPSOC_HEARTBEAT_RESETS, new PoolEntry<uint32_t>({0}));
+  localDataPoolMap.emplace(supv::LAST_RECVD_TC, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::CPU_WDT_RESETS, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::PS_HEARTBEATS_LOST, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::PL_HEARTBEATS_LOST, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::EB_TASK_LOST, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::BM_TASK_LOST, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::LM_TASK_LOST, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::AM_TASK_LOST, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::TCTMM_TASK_LOST, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::MM_TASK_LOST, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::HK_TASK_LOST, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::DL_TASK_LOST, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(supv::RWS_TASKS_LOST, new PoolEntry<uint32_t>(3));
-  localDataPoolMap.emplace(supv::ADC_RAW, &adcRawEntry);
+  localDataPoolMap.emplace(supv::ADC_RAW_0, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(supv::ADC_ENG, &adcEngEntry);
+  localDataPoolMap.emplace(supv::ADC_RAW_1, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_2, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_3, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_4, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_5, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_6, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_7, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_8, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_9, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_10, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_11, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_12, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_13, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_14, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_RAW_15, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_0, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_1, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_2, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_3, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_4, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_5, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_6, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_7, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_8, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_9, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_10, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_11, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_12, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_13, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_14, new PoolEntry<uint16_t>({0}));
  localDataPoolMap.emplace(supv::ADC_ENG_15, new PoolEntry<uint16_t>({0}));
  poolManager.subscribeForRegularPeriodicPacket(
      subdp::RegularHkPeriodicParams(hkset.getSid(), false, 10.0));
@ -920,7 +920,6 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionReport(const uint8_t* data)
  } else if (tmReader.getServiceId() == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK)) {
    handleExecutionFailureReport(report);
  }
  commandIsPending = false;
  nextReplyId = supv::NONE;
  return result;
 }
@ -1155,31 +1154,37 @@ ReturnValue_t PlocSupervisorHandler::handleLatchupStatusReport(const uint8_t* da
  return result;
 }
-ReturnValue_t PlocSupervisorHandler::genericHandleTm(const char* contextString, const uint8_t* data,
+ReturnValue_t PlocSupervisorHandler::handleAdcReport(const uint8_t* data) {
                                                     LocalPoolDataSetBase& set) {
  ReturnValue_t result = returnvalue::OK;
-  result = verifyPacket(data, tmReader.getFullPacketLen());
+  result = verifyPacket(data, supv::SIZE_ADC_REPORT);
  if (result == result::CRC_FAILURE) {
-    sif::warning << "PlocSupervisorHandler: " << contextString << " report has "
+    sif::error << "PlocSupervisorHandler::handleAdcReport: ADC report has "
-                 << "invalid CRC" << std::endl;
+               << "invalid crc" << std::endl;
    return result;
  }
  const uint8_t* dataField = data + supv::PAYLOAD_OFFSET;
-  PoolReadGuard pg(&set);
+  result = adcReport.read();
-  if (pg.getReadResult() != returnvalue::OK) {
+  if (result != returnvalue::OK) {
    return result;
  }
-  set.setValidityBufferGeneration(false);
+  adcReport.setValidityBufferGeneration(false);
-  size_t size = set.getSerializedSize();
+  size_t size = adcReport.getSerializedSize();
-  result = set.deSerialize(&dataField, &size, SerializeIF::Endianness::BIG);
+  result = adcReport.deSerialize(&dataField, &size, SerializeIF::Endianness::BIG);
  if (result != returnvalue::OK) {
-    sif::warning << "PlocSupervisorHandler: Deserialization failed" << std::endl;
+    sif::warning << "PlocSupervisorHandler::handleAdcReport: Deserialization failed" << std::endl;
  }
-  set.setValidityBufferGeneration(true);
+  adcReport.setValidityBufferGeneration(true);
-  set.setValidity(true, true);
+  adcReport.setValidity(true, true);
  result = adcReport.commit();
  if (result != returnvalue::OK) {
    return result;
  }
 #if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
  adcReport.printSet();
 #endif
  nextReplyId = supv::EXE_REPORT;
  return result;
 }
@ -1201,8 +1206,8 @@ void PlocSupervisorHandler::setNextReplyId() {
    case supv::CONSECUTIVE_MRAM_DUMP:
      nextReplyId = supv::CONSECUTIVE_MRAM_DUMP;
      break;
-    case supv::REQUEST_LOGGING_COUNTERS:
+    case supv::LOGGING_REQUEST_COUNTERS:
-      nextReplyId = supv::COUNTERS_REPORT;
+      nextReplyId = supv::LOGGING_REPORT;
      break;
    case supv::REQUEST_ADC_REPORT:
      nextReplyId = supv::ADC_REPORT;
@ -1281,7 +1286,7 @@ ReturnValue_t PlocSupervisorHandler::prepareEmptyCmd(uint16_t apid, uint8_t serv
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
@ -1292,7 +1297,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSelBootImageCmd(const uint8_t* comma
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
@ -1309,7 +1314,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSetTimeRefCmd() {
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
@ -1319,7 +1324,7 @@ ReturnValue_t PlocSupervisorHandler::prepareDisableHk() {
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
@ -1331,7 +1336,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSetBootTimeoutCmd(const uint8_t* com
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
@ -1342,7 +1347,7 @@ ReturnValue_t PlocSupervisorHandler::prepareRestartTriesCmd(const uint8_t* comma
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
@ -1360,7 +1365,7 @@ ReturnValue_t PlocSupervisorHandler::prepareLatchupConfigCmd(const uint8_t* comm
      if (result != returnvalue::OK) {
        return result;
      }
-      finishTcPrep(packet);
+      finishTcPrep(packet.getFullPacketLen());
      break;
    }
    case (supv::DISABLE_LATCHUP_ALERT): {
@ -1369,7 +1374,7 @@ ReturnValue_t PlocSupervisorHandler::prepareLatchupConfigCmd(const uint8_t* comm
      if (result != returnvalue::OK) {
        return result;
      }
-      finishTcPrep(packet);
+      finishTcPrep(packet.getFullPacketLen());
      break;
    }
    default: {
@ -1396,7 +1401,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAlertLimitCmd(const uint8_t* comm
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
@ -1407,7 +1412,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAdcEnabledChannelsCmd(const uint8
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
@ -1421,7 +1426,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAdcWindowAndStrideCmd(const uint8
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
@ -1433,7 +1438,7 @@ ReturnValue_t PlocSupervisorHandler::prepareSetAdcThresholdCmd(const uint8_t* co
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
@ -1447,15 +1452,11 @@ ReturnValue_t PlocSupervisorHandler::prepareRunAutoEmTest(const uint8_t* command
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
-ReturnValue_t PlocSupervisorHandler::prepareSetGpioCmd(const uint8_t* commandData,
+ReturnValue_t PlocSupervisorHandler::prepareSetGpioCmd(const uint8_t* commandData) {
                                                       size_t commandDataLen) {
  if (commandDataLen < 3) {
    return HasActionsIF::INVALID_PARAMETERS;
  }
  uint8_t port = *commandData;
  uint8_t pin = *(commandData + 1);
  uint8_t val = *(commandData + 2);
@ -1464,15 +1465,11 @@ ReturnValue_t PlocSupervisorHandler::prepareSetGpioCmd(const uint8_t* commandDat
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
-ReturnValue_t PlocSupervisorHandler::prepareReadGpioCmd(const uint8_t* commandData,
+ReturnValue_t PlocSupervisorHandler::prepareReadGpioCmd(const uint8_t* commandData) {
                                                        size_t commandDataLen) {
  if (commandDataLen < 2) {
    return HasActionsIF::INVALID_PARAMETERS;
  }
  uint8_t port = *commandData;
  uint8_t pin = *(commandData + 1);
  supv::ReadGpio packet(spParams);
@ -1480,7 +1477,7 @@ ReturnValue_t PlocSupervisorHandler::prepareReadGpioCmd(const uint8_t* commandDa
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
@ -1494,18 +1491,14 @@ ReturnValue_t PlocSupervisorHandler::prepareFactoryResetCmd(const uint8_t* comma
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(resetCmd);
+  finishTcPrep(resetCmd.getFullPacketLen());
  return returnvalue::OK;
 }
-void PlocSupervisorHandler::finishTcPrep(TcBase& tc) {
+void PlocSupervisorHandler::finishTcPrep(size_t packetLen) {
  nextReplyId = supv::ACK_REPORT;
  rawPacket = commandBuffer;
-  rawPacketLen = tc.getFullPacketLen();
+  rawPacketLen = packetLen;
  if (DEBUG_PLOC_SUPV) {
    sif::debug << "PLOC SUPV: SEND PACKET Size " << tc.getFullPacketLen() << " Module APID "
               << (int)tc.getModuleApid() << " Service ID " << (int)tc.getServiceId() << std::endl;
  }
 }
 ReturnValue_t PlocSupervisorHandler::prepareSetShutdownTimeoutCmd(const uint8_t* commandData) {
@ -1518,14 +1511,13 @@ ReturnValue_t PlocSupervisorHandler::prepareSetShutdownTimeoutCmd(const uint8_t*
    sif::warning
        << "PlocSupervisorHandler::prepareSetShutdownTimeoutCmd: Failed to deserialize timeout"
        << std::endl;
    return result;
  }
  supv::SetShutdownTimeout packet(spParams);
  result = packet.buildPacket(timeout);
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
@ -1535,13 +1527,7 @@ void PlocSupervisorHandler::disableAllReplies() {
  /* Disable ack reply */
  iter = deviceReplyMap.find(ACK_REPORT);
  if (iter == deviceReplyMap.end()) {
    return;
  }
  DeviceReplyInfo* info = &(iter->second);
  if (info == nullptr) {
    return;
  }
  info->delayCycles = 0;
  info->command = deviceCommandMap.end();
@ -1570,8 +1556,8 @@ void PlocSupervisorHandler::disableAllReplies() {
      disableReply(LATCHUP_REPORT);
      break;
    }
-    case REQUEST_LOGGING_COUNTERS: {
+    case LOGGING_REQUEST_COUNTERS: {
-      disableReply(COUNTERS_REPORT);
+      disableReply(LOGGING_REPORT);
      break;
    }
    default: {
@ -1585,9 +1571,6 @@ void PlocSupervisorHandler::disableAllReplies() {
 void PlocSupervisorHandler::disableReply(DeviceCommandId_t replyId) {
  DeviceReplyMap::iterator iter = deviceReplyMap.find(replyId);
  if (iter == deviceReplyMap.end()) {
    return;
  }
  DeviceReplyInfo* info = &(iter->second);
  info->delayCycles = 0;
  info->active = false;
@ -1618,9 +1601,6 @@ void PlocSupervisorHandler::sendFailureReport(DeviceCommandId_t replyId, ReturnV
 void PlocSupervisorHandler::disableExeReportReply() {
  DeviceReplyIter iter = deviceReplyMap.find(supv::EXE_REPORT);
  if (iter == deviceReplyMap.end()) {
    return;
  }
  DeviceReplyInfo* info = &(iter->second);
  info->delayCycles = 0;
  info->command = deviceCommandMap.end();
@ -1643,9 +1623,7 @@ ReturnValue_t PlocSupervisorHandler::handleMramDumpPacket(DeviceCommandId_t id)
    result = handleMramDumpFile(id);
    if (result != returnvalue::OK) {
      DeviceCommandMap::iterator iter = deviceCommandMap.find(id);
-      if (iter != deviceCommandMap.end()) {
+      actionHelper.finish(false, iter->second.sendReplyTo, id, result);
        actionHelper.finish(false, iter->second.sendReplyTo, id, result);
      }
      disableAllReplies();
      nextReplyId = supv::NONE;
      return result;
@ -1750,7 +1728,7 @@ ReturnValue_t PlocSupervisorHandler::prepareWipeMramCmd(const uint8_t* commandDa
  if (result != returnvalue::OK) {
    return result;
  }
-  finishTcPrep(packet);
+  finishTcPrep(packet.getFullPacketLen());
  return returnvalue::OK;
 }
@ -1912,12 +1890,7 @@ ReturnValue_t PlocSupervisorHandler::eventSubscription() {
 ReturnValue_t PlocSupervisorHandler::handleExecutionSuccessReport(ExecutionReport& report) {
  DeviceCommandId_t commandId = getPendingCommand();
-  DeviceCommandMap::iterator iter = deviceCommandMap.find(commandId);
+  ReturnValue_t result = OK;
  if (iter != deviceCommandMap.end() and iter->second.sendReplyTo != NO_COMMANDER) {
    actionHelper.finish(true, iter->second.sendReplyTo, iter->first, returnvalue::OK);
    iter->second.isExecuting = false;
  }
  commandIsPending = false;
  switch (commandId) {
    case supv::READ_GPIO: {
      // TODO: Fix
@ -1925,13 +1898,14 @@ ReturnValue_t PlocSupervisorHandler::handleExecutionSuccessReport(ExecutionRepor
 #if OBSW_DEBUG_PLOC_SUPERVISOR == 1
      sif::info << "PlocSupervisorHandler: Read GPIO TM, State: " << gpioState << std::endl;
 #endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */
-      if (iter != deviceCommandMap.end() and iter->second.sendReplyTo == NO_COMMAND_ID) {
+      DeviceCommandMap::iterator iter = deviceCommandMap.find(commandId);
      if (iter->second.sendReplyTo == NO_COMMAND_ID) {
        return returnvalue::OK;
      }
      uint8_t data[sizeof(gpioState)];
      size_t size = 0;
-      ReturnValue_t result = SerializeAdapter::serialize(&gpioState, data, &size, sizeof(gpioState),
+      result = SerializeAdapter::serialize(&gpioState, data, &size, sizeof(gpioState),
-                                                         SerializeIF::Endianness::BIG);
+                                           SerializeIF::Endianness::BIG);
      if (result != returnvalue::OK) {
        sif::debug << "PlocSupervisorHandler: Failed to deserialize GPIO state" << std::endl;
      }
@ -2007,21 +1981,133 @@ uint32_t PlocSupervisorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t mod
  return 7000;
 }
-void PlocSupervisorHandler::disableCommand(DeviceCommandId_t cmd) {
+// ReturnValue_t PlocSupervisorHandler::checkMramPacketApid() {
-  auto commandIter = deviceCommandMap.find(GET_HK_REPORT);
+//   uint16_t apid = (spacePacketBuffer[0] << 8 | spacePacketBuffer[1]) & supv::APID_MASK;
-  commandIter->second.isExecuting = false;
+//  TODO: Fix
-}
+//  if (apid != supv::APID_MRAM_DUMP_TM) {
 //    return result::NO_MRAM_PACKET;
 //  }
 // return APERIODIC_REPLY;
 //}
-ReturnValue_t PlocSupervisorHandler::checkModeCommand(Mode_t commandedMode,
+// ReturnValue_t PlocSupervisorHandler::parseMramPackets(const uint8_t* packet, size_t
-                                                      Submode_t commandedSubmode,
+// remainingSize,
-                                                      uint32_t* msToReachTheMode) {
+//                                                       size_t* foundLen) {
-  if (commandedMode != MODE_OFF) {
+//   ReturnValue_t result = IGNORE_FULL_PACKET;
-    PoolReadGuard pg(&enablePl);
+//   uint16_t packetLen = 0;
-    if (pg.getReadResult() == returnvalue::OK) {
+//   *foundLen = 0;
-      if (enablePl.plUseAllowed.isValid() and not enablePl.plUseAllowed.value) {
+//
-        return NON_OP_STATE_OF_CHARGE;
+//   for (size_t idx = 0; idx < remainingSize; idx++) {
-      }
+//     std::memcpy(spacePacketBuffer + bufferTop, packet + idx, 1);
-    }
+//     bufferTop += 1;
-  }
+//     *foundLen += 1;
-  return DeviceHandlerBase::checkModeCommand(commandedMode, commandedSubmode, msToReachTheMode);
+//     if (bufferTop >= ccsds::HEADER_LEN) {
-}
+//       packetLen = readSpacePacketLength(spacePacketBuffer);
 //     }
 //
 //     if (bufferTop == ccsds::HEADER_LEN + packetLen + 1) {
 //       packetInBuffer = true;
 //       bufferTop = 0;
 //       return checkMramPacketApid();
 //     }
 //
 //     if (bufferTop == supv::MAX_PACKET_SIZE) {
 //       *foundLen = remainingSize;
 //       disableAllReplies();
 //       bufferTop = 0;
 //       sif::info << "PlocSupervisorHandler::parseMramPackets: Can not find MRAM packet in space "
 //                    "packet buffer"
 //                 << std::endl;
 //       return result::MRAM_PACKET_PARSING_FAILURE;
 //     }
 //   }
 //
 //   return result;
 // }
 // ReturnValue_t PlocSupervisorHandler::prepareDumpMramCmd(const uint8_t* commandData) {
 //   uint32_t start = 0;
 //   uint32_t stop = 0;
 //   size_t size = sizeof(start) + sizeof(stop);
 //   SerializeAdapter::deSerialize(&start, &commandData, &size, SerializeIF::Endianness::BIG);
 //   SerializeAdapter::deSerialize(&stop, &commandData, &size, SerializeIF::Endianness::BIG);
 //   if ((stop - start) <= 0) {
 //     return SupvReturnValuesIF::INVALID_MRAM_ADDRESSES;
 //   }
 //   supv::MramCmd packet(spParams);
 //   ReturnValue_t result = packet.buildPacket(start, stop, supv::MramCmd::MramAction::DUMP);
 //   if (result != returnvalue::OK) {
 //     return result;
 //   }
 //   expectedMramDumpPackets = (stop - start) / supv::MAX_DATA_CAPACITY;
 //   if ((stop - start) % supv::MAX_DATA_CAPACITY) {
 //     expectedMramDumpPackets++;
 //   }
 //   receivedMramDumpPackets = 0;
 //
 //   finishTcPrep(packet.getFullPacketLen());
 //   return returnvalue::OK;
 // }
 // ReturnValue_t PlocSupervisorHandler::prepareLoggingRequest(const uint8_t* commandData,
 //                                                            size_t commandDataLen) {
 //   using namespace supv;
 //   RequestLoggingData::Sa sa = static_cast<RequestLoggingData::Sa>(*commandData);
 //   uint8_t tpc = *(commandData + 1);
 //   RequestLoggingData packet(spParams);
 //   ReturnValue_t result = packet.buildPacket(sa, tpc);
 //   if (result != returnvalue::OK) {
 //     return result;
 //   }
 //   finishTcPrep(packet.getFullPacketLen());
 //   return returnvalue::OK;
 // }
 // ReturnValue_t PlocSupervisorHandler::prepareEnableNvmsCommand(const uint8_t* commandData) {
 //   using namespace supv;
 //   uint8_t nvm01 = *(commandData);
 //   uint8_t nvm3 = *(commandData + 1);
 //   EnableNvms packet(spParams);
 //   ReturnValue_t result = packet.buildPacket(nvm01, nvm3);
 //   if (result != returnvalue::OK) {
 //     return result;
 //   }
 //   finishTcPrep(packet.getFullPacketLen());
 //   return returnvalue::OK;
 // }
 // ReturnValue_t PlocSupervisorHandler::handleLoggingReport(const uint8_t* data) {
 //   ReturnValue_t result = returnvalue::OK;
 //
 //   result = verifyPacket(data, supv::SIZE_LOGGING_REPORT);
 //
 //   if (result == SupvReturnValuesIF::CRC_FAILURE) {
 //     sif::warning << "PlocSupervisorHandler::handleLoggingReport: Logging report has "
 //                  << "invalid crc" << std::endl;
 //     return result;
 //   }
 //
 //   const uint8_t* dataField = data + supv::PAYLOAD_OFFSET + sizeof(supv::RequestLoggingData::Sa);
 //   result = loggingReport.read();
 //   if (result != returnvalue::OK) {
 //     return result;
 //   }
 //   loggingReport.setValidityBufferGeneration(false);
 //   size_t size = loggingReport.getSerializedSize();
 //   result = loggingReport.deSerialize(&dataField, &size, SerializeIF::Endianness::BIG);
 //   if (result != returnvalue::OK) {
 //     sif::warning << "PlocSupervisorHandler::handleLoggingReport: Deserialization failed"
 //                  << std::endl;
 //   }
 //   loggingReport.setValidityBufferGeneration(true);
 //   loggingReport.setValidity(true, true);
 //   result = loggingReport.commit();
 //   if (result != returnvalue::OK) {
 //     return result;
 //   }
 // #if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_PLOC_SUPERVISOR == 1
 //   loggingReport.printSet();
 // #endif
 //   nextReplyId = supv::EXE_REPORT;
 //   return result;
 // }
--- a/linux/payload/PlocSupervisorHandler.h
+++ b/linux/payload/PlocSupervisorHandler.h
@ -3,7 +3,6 @@
 #include <linux/payload/PlocSupvUartMan.h>
 #include <linux/payload/plocSupvDefs.h>
 #include <mission/controller/controllerdefinitions/PowerCtrlDefinitions.h>
 #include "OBSWConfig.h"
 #include "devices/powerSwitcherList.h"
@ -18,10 +17,6 @@
 #endif
 using supv::ExecutionReport;
 using supv::TcBase;
 static constexpr bool DEBUG_PLOC_SUPV = true;
 static constexpr bool REDUCE_NORMAL_MODE_PRINTOUT = true;
 /**
 * @brief	This is the device handler for the supervisor of the PLOC which is programmed by
@ -68,6 +63,26 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
  void doOffActivity() override;
 private:
  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_SUPERVISOR_HANDLER;
  //! [EXPORT] : [COMMENT] PLOC supervisor crc failure in telemetry packet
  static const Event SUPV_MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW);
  //! [EXPORT] : [COMMENT] Unhandled event. P1: APID, P2: Service ID
  static constexpr Event SUPV_UNKNOWN_TM = MAKE_EVENT(2, severity::LOW);
  static constexpr Event SUPV_UNINIMPLEMENTED_TM = MAKE_EVENT(3, severity::LOW);
  //! [EXPORT] : [COMMENT] PLOC supervisor received acknowledgment failure report
  static const Event SUPV_ACK_FAILURE = MAKE_EVENT(4, severity::LOW);
  //! [EXPORT] : [COMMENT] PLOC received execution failure report
  //! P1: ID of command for which the execution failed
  //! P2: Status code sent by the supervisor handler
  static const Event SUPV_EXE_FAILURE = MAKE_EVENT(5, severity::LOW);
  //! [EXPORT] : [COMMENT] PLOC supervisor reply has invalid crc
  static const Event SUPV_CRC_FAILURE_EVENT = MAKE_EVENT(6, severity::LOW);
  //! [EXPORT] : [COMMENT] Supervisor helper currently executing a command
  static const Event SUPV_HELPER_EXECUTING = MAKE_EVENT(7, severity::LOW);
  //! [EXPORT] : [COMMENT] Failed to build the command to shutdown the MPSoC
  static const Event SUPV_MPSOC_SHUTDOWN_BUILD_FAILED = MAKE_EVENT(8, severity::LOW);
  static const uint16_t APID_MASK = 0x7FF;
  static const uint16_t PACKET_SEQUENCE_COUNT_MASK = 0x3FFF;
  static const uint8_t EXE_STATUS_OFFSET = 10;
@ -75,14 +90,15 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
  // 5 s
  static const uint32_t EXECUTION_DEFAULT_TIMEOUT = 5000;
  // 70 S
-  static const uint32_t ACKNOWLEDGE_DEFAULT_TIMEOUT = 5000;
+  static const uint32_t ACKNOWLEDGE_DEFAULT_TIMEOUT = 70000;
  // 60 s
  static const uint32_t MRAM_DUMP_EXECUTION_TIMEOUT = 60000;
  // 70 s
  static const uint32_t COPY_ADC_TO_MRAM_TIMEOUT = 70000;
  // 60 s
  static const uint32_t MRAM_DUMP_TIMEOUT = 60000;
-
+  // 4 s
  static const uint32_t BOOT_TIMEOUT = 4000;
  enum class StartupState : uint8_t {
    OFF,
    BOOTING,
@ -111,18 +127,11 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
  LinuxLibgpioIF* gpioComIF = nullptr;
  Gpio uartIsolatorSwitch;
  bool shutdownCmdSent = false;
  // Yeah, I am using an extra variable because I once again don't know
  // what the hell the base class is doing and I don't care anymore.
  bool normalCommandIsPending = false;
  // True men implement their reply timeout handling themselves!
  Countdown normalCmdCd = Countdown(2000);
  bool commandIsPending = false;
  Countdown cmdCd = Countdown(2000);
  supv::HkSet hkset;
  supv::BootStatusReport bootStatusReport;
  supv::LatchupStatusReport latchupStatusReport;
-  supv::CountersReport countersReport;
+  supv::LoggingReport loggingReport;
  supv::AdcReport adcReport;
  const power::Switch_t powerSwitch = power::NO_SWITCH;
@ -151,12 +160,9 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
  Countdown executionReportTimeout = Countdown(EXECUTION_DEFAULT_TIMEOUT, false);
  Countdown acknowledgementReportTimeout = Countdown(ACKNOWLEDGE_DEFAULT_TIMEOUT, false);
  // Vorago nees some time to boot properly
-  Countdown bootTimeout = Countdown(supv::BOOT_TIMEOUT_MS);
+  Countdown bootTimeout = Countdown(BOOT_TIMEOUT);
  Countdown mramDumpTimeout = Countdown(MRAM_DUMP_TIMEOUT);
  PoolEntry<uint16_t> adcRawEntry = PoolEntry<uint16_t>(16);
  PoolEntry<uint16_t> adcEngEntry = PoolEntry<uint16_t>(16);
  PoolEntry<uint32_t> latchupCounters = PoolEntry<uint32_t>(7);
  PoolEntry<uint8_t> fmcStateEntry = PoolEntry<uint8_t>(1);
  PoolEntry<uint8_t> bootStateEntry = PoolEntry<uint8_t>(1);
  PoolEntry<uint8_t> bootCyclesEntry = PoolEntry<uint8_t>(1);
@ -167,8 +173,6 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   */
  void setExecutionTimeout(DeviceCommandId_t command);
  void handlePacketPrint();
  /**
   * @brief   Handles event messages received from the supervisor helper
   */
@ -221,13 +225,9 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
  ReturnValue_t handleBootStatusReport(const uint8_t* data);
  ReturnValue_t handleLatchupStatusReport(const uint8_t* data);
  ReturnValue_t handleCounterReport(const uint8_t* data);
  void handleBadApidServiceCombination(Event result, unsigned int apid, unsigned int serviceId);
  // ReturnValue_t handleLoggingReport(const uint8_t* data);
  ReturnValue_t handleAdcReport(const uint8_t* data);
  ReturnValue_t genericHandleTm(const char* contextString, const uint8_t* data,
                                LocalPoolDataSetBase& set);
  void disableCommand(DeviceCommandId_t cmd);
  /**
   * @brief   Depending on the current active command, this function sets the reply id of the
@ -296,13 +296,16 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
  ReturnValue_t prepareSetAdcThresholdCmd(const uint8_t* commandData);
  ReturnValue_t prepareRunAutoEmTest(const uint8_t* commandData);
  ReturnValue_t prepareWipeMramCmd(const uint8_t* commandData);
-  ReturnValue_t prepareSetGpioCmd(const uint8_t* commandData, size_t commandDataLen);
+  // ReturnValue_t prepareDumpMramCmd(const uint8_t* commandData);
-  ReturnValue_t prepareReadGpioCmd(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t prepareSetGpioCmd(const uint8_t* commandData);
  ReturnValue_t prepareReadGpioCmd(const uint8_t* commandData);
  // ReturnValue_t prepareLoggingRequest(const uint8_t* commandData, size_t commandDataLen);
  //  ReturnValue_t prepareEnableNvmsCommand(const uint8_t* commandData);
  /**
   * @brief   Copies the content of a space packet to the command buffer.
   */
-  void finishTcPrep(TcBase& tc);
+  void finishTcPrep(size_t packetLen);
  /**
   * @brief   In case an acknowledgment failure reply has been received this function disables
@ -328,6 +331,12 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   */
  void disableExeReportReply();
  /**
   * @brief   Function is called in scanForReply and fills the spacePacketBuffer with the read
   *          data until a full packet has been received.
   */
  // ReturnValue_t parseMramPackets(const uint8_t* packet, size_t remainingSize, size_t* foundlen);
  /**
   * @brief   This function generates the Service 8 packets for the MRAM dump data.
   */
@ -340,6 +349,12 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
   */
  void increaseExpectedMramReplies(DeviceCommandId_t id);
  /**
   * @brief   Function checks if the packet written to the space packet buffer is really a
   *          MRAM dump packet.
   */
  // ReturnValue_t checkMramPacketApid();
  /**
   * @brief   Writes the data of the MRAM dump to a file. The file will be created when receiving
   *          the first packet.
@ -380,10 +395,6 @@ class PlocSupervisorHandler : public DeviceHandlerBase {
  void handleExecutionFailureReport(ExecutionReport& report);
  void printAckFailureInfo(uint16_t statusCode, DeviceCommandId_t commandId);
  pwrctrl::EnablePl enablePl = pwrctrl::EnablePl(objects::POWER_CONTROLLER);
  ReturnValue_t checkModeCommand(Mode_t commandedMode, Submode_t commandedSubmode,
                                 uint32_t* msToReachTheMode) override;
 };
 #endif /* MISSION_DEVICES_PLOCSUPERVISORHANDLER_H_ */
--- a/linux/payload/PlocSupvUartMan.cpp
+++ b/linux/payload/PlocSupvUartMan.cpp
@ -11,8 +11,6 @@
 #include <fstream>
 #include "OBSWConfig.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "linux/payload/plocSupvDefs.h"
 #include "tas/hdlc.h"
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/FilesystemHelper.h"
@ -23,14 +21,9 @@
 #include "fsfw/tasks/TaskFactory.h"
 #include "fsfw/timemanager/Countdown.h"
 #if OBSW_DEBUG_PLOC_SUPERVISOR == 1
 #include "mission/utility/Filenaming.h"
 #include "mission/utility/ProgressPrinter.h"
 #include "mission/utility/Timestamp.h"
 #endif
 #include "tas/crc.h"
 using namespace returnvalue;
 using namespace supv;
@ -103,10 +96,9 @@ ReturnValue_t PlocSupvUartManager::initialize() {
 ReturnValue_t PlocSupvUartManager::performOperation(uint8_t operationCode) {
  bool putTaskToSleep = false;
  while (true) {
-    {
+    lock->lockMutex();
-      MutexGuard mg(lock);
+    state = InternalState::SLEEPING;
-      state = InternalState::SLEEPING;
+    lock->unlockMutex();
    }
    semaphore->acquire();
    putTaskToSleep = false;
 #if OBSW_THREAD_TRACING == 1
@ -118,11 +110,9 @@ ReturnValue_t PlocSupvUartManager::performOperation(uint8_t operationCode) {
        break;
      }
      handleUartReception();
-      InternalState currentState;
+      lock->lockMutex();
-      {
+      InternalState currentState = state;
-        MutexGuard mg(lock);
+      lock->unlockMutex();
        currentState = state;
      }
      switch (currentState) {
        case InternalState::SLEEPING:
        case InternalState::GO_TO_SLEEP: {
@ -166,7 +156,7 @@ ReturnValue_t PlocSupvUartManager::handleUartReception() {
               << " bytes" << std::endl;
    return FAILED;
  } else if (bytesRead > 0) {
-    if (DEBUG_MODE) {
+    if (debugMode) {
      sif::info << "Received " << bytesRead << " bytes from the PLOC Supervisor:" << std::endl;
      arrayprinter::print(recBuf.data(), bytesRead);
    }
@ -283,6 +273,23 @@ ReturnValue_t PlocSupvUartManager::initiateUpdateContinuation() {
  return returnvalue::OK;
 }
 // ReturnValue_t PlocSupvHelper::startEventBufferRequest(std::string path) {
 // #ifdef XIPHOS_Q7S
 //   ReturnValue_t result = FilesystemHelper::checkPath(path);
 //   if (result != returnvalue::OK) {
 //     return result;
 //   }
 // #endif
 //   if (not std::filesystem::exists(path)) {
 //     return PATH_NOT_EXISTS;
 //   }
 //   eventBufferReq.path = path;
 //   request = Request::REQUEST_EVENT_BUFFER;
 //   //uartComIF->flushUartTxAndRxBuf(comCookie);
 //   semaphore->release();
 //   return returnvalue::OK;
 // }
 void PlocSupvUartManager::stop() {
  MutexGuard mg(lock);
  if (state == InternalState::SLEEPING or state == InternalState::GO_TO_SLEEP) {
@ -426,8 +433,6 @@ ReturnValue_t PlocSupvUartManager::writeUpdatePackets() {
        // Useful to allow restarting the update
        triggerEvent(SUPV_UPDATE_PROGRESS, buildProgParams1(progPercent, update.sequenceCount),
                     update.bytesWritten);
        sif::info << "PLOC SUPV update progress " << (int)progPercent << " % at "
                  << update.bytesWritten << " bytes" << std::endl;
      }
    }
    supv::WriteMemory packet(spParams);
@ -438,8 +443,10 @@ ReturnValue_t PlocSupvUartManager::writeUpdatePackets() {
                   update.bytesWritten);
      return result;
    }
-    result = writeMemoryHandlingWithRetryLogic(packet, progPercent);
+    result = handlePacketTransmissionNoReply(packet, 5000);
    if (result != returnvalue::OK) {
      triggerEvent(WRITE_MEMORY_FAILED, buildProgParams1(progPercent, update.sequenceCount),
                   update.bytesWritten);
      return result;
    }
@ -450,25 +457,7 @@ ReturnValue_t PlocSupvUartManager::writeUpdatePackets() {
 #if OBSW_DEBUG_PLOC_SUPERVISOR == 1
    progressPrinter.print(update.bytesWritten);
 #endif /* OBSW_DEBUG_PLOC_SUPERVISOR == 1 */
-  }
+    // TaskFactory::delayTask(1);
  return result;
 }
 ReturnValue_t PlocSupvUartManager::writeMemoryHandlingWithRetryLogic(supv::WriteMemory& packet,
                                                                     unsigned progPercent) {
  ReturnValue_t result = returnvalue::OK;
  // Simple re-try logic in place to deal with communication unreliability in orbit.
  for (uint8_t retryCount = 0; retryCount < MAX_RETRY_COUNT; retryCount++) {
    result = handlePacketTransmissionNoReply(packet, COM_TIMEOUT_MS);
    if (result == returnvalue::OK) {
      return result;
    }
    triggerEvent(WRITE_MEMORY_FAILED, buildProgParams1(progPercent, update.sequenceCount),
                 update.bytesWritten);
    // Clear data structures related to reply handling.
    serial::flushTxRxBuf(serialPort);
    recRingBuf.clear();
    decodedRingBuf.clear();
  }
  return result;
 }
@ -577,21 +566,12 @@ ReturnValue_t PlocSupvUartManager::handlePacketTransmissionNoReply(
  bool ackReceived = false;
  bool packetWasHandled = false;
  while (true) {
-    ReturnValue_t status = handleUartReception();
+    handleUartReception();
    if (status != returnvalue::OK) {
      result = status;
      if (result == HDLC_ERROR) {
        // We could bail here immediately.. but I prefer to wait for the timeout, because we should
        // ensure that all packets which might be related to the transfer are still received and
        // cleared from all data structures related to reply handling.
        // return result;
      }
    }
    if (not decodedQueue.empty()) {
      size_t packetLen = 0;
      decodedQueue.retrieve(&packetLen);
      decodedRingBuf.readData(decodedBuf.data(), packetLen, true);
-      tmReader.setReadOnlyData(decodedBuf.data(), packetLen);
+      tmReader.setData(decodedBuf.data(), packetLen);
      result = checkReceivedTm();
      if (result != returnvalue::OK) {
        continue;
@ -629,7 +609,7 @@ ReturnValue_t PlocSupvUartManager::handlePacketTransmissionNoReply(
      return result::NO_REPLY_TIMEOUT;
    }
  }
-  return result;
+  return returnvalue::OK;
 }
 int PlocSupvUartManager::handleAckReception(supv::TcBase& tc, size_t packetLen) {
@ -637,7 +617,7 @@ int PlocSupvUartManager::handleAckReception(supv::TcBase& tc, size_t packetLen)
  if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::ACK) or
      serviceId == static_cast<uint8_t>(supv::tm::TmtcId::NAK)) {
    AcknowledgmentReport ackReport(tmReader);
-    ReturnValue_t result = ackReport.parse(false);
+    ReturnValue_t result = ackReport.parse();
    if (result != returnvalue::OK) {
      triggerEvent(ACK_RECEPTION_FAILURE);
      return -1;
@ -647,7 +627,7 @@ int PlocSupvUartManager::handleAckReception(supv::TcBase& tc, size_t packetLen)
      if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::ACK)) {
        return 1;
      } else if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::NAK)) {
-        ackReport.printStatusInformationAck();
+        ackReport.printStatusInformation();
        triggerEvent(
            SUPV_ACK_FAILURE_REPORT,
            buildApidServiceParam1(ackReport.getRefModuleApid(), ackReport.getRefServiceId()),
@ -669,7 +649,7 @@ int PlocSupvUartManager::handleExeAckReception(supv::TcBase& tc, size_t packetLe
  if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_ACK) or
      serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK)) {
    ExecutionReport exeReport(tmReader);
-    ReturnValue_t result = exeReport.parse(false);
+    ReturnValue_t result = exeReport.parse();
    if (result != returnvalue::OK) {
      triggerEvent(EXE_RECEPTION_FAILURE);
      return -1;
@ -679,7 +659,7 @@ int PlocSupvUartManager::handleExeAckReception(supv::TcBase& tc, size_t packetLe
      if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_ACK)) {
        return 1;
      } else if (serviceId == static_cast<uint8_t>(supv::tm::TmtcId::EXEC_NAK)) {
-        exeReport.printStatusInformationExe();
+        exeReport.printStatusInformation();
        triggerEvent(
            SUPV_EXE_FAILURE_REPORT,
            buildApidServiceParam1(exeReport.getRefModuleApid(), exeReport.getRefServiceId()),
@ -702,7 +682,7 @@ ReturnValue_t PlocSupvUartManager::checkReceivedTm() {
    triggerEvent(SUPV_REPLY_SIZE_MISSMATCH, rememberApid);
    return result;
  }
-  if (tmReader.checkCrc() != returnvalue::OK) {
+  if (not tmReader.verifyCrc()) {
    triggerEvent(SUPV_REPLY_CRC_MISSMATCH, rememberApid);
    return result;
  }
@ -778,7 +758,7 @@ ReturnValue_t PlocSupvUartManager::handleCheckMemoryCommand(uint8_t failStep) {
      size_t packetLen = 0;
      decodedQueue.retrieve(&packetLen);
      decodedRingBuf.readData(decodedBuf.data(), packetLen, true);
-      tmReader.setReadOnlyData(decodedBuf.data(), packetLen);
+      tmReader.setData(decodedBuf.data(), packetLen);
      result = checkReceivedTm();
      if (result != returnvalue::OK) {
        continue;
@ -806,7 +786,7 @@ ReturnValue_t PlocSupvUartManager::handleCheckMemoryCommand(uint8_t failStep) {
      } else if (tmReader.getModuleApid() == Apid::MEM_MAN) {
        if (ackReceived) {
          supv::UpdateStatusReport report(tmReader);
-          result = report.parse(false);
+          result = report.parse();
          if (result != returnvalue::OK) {
            return result;
          }
@ -961,7 +941,15 @@ ReturnValue_t PlocSupvUartManager::handleRunningLongerRequest() {
      break;
    }
    case Request::REQUEST_EVENT_BUFFER: {
-      sif::error << "Requesting event buffer is not implemented" << std::endl;
+      //      result = performEventBufferRequest();
      //      if (result == returnvalue::OK) {
      //        triggerEvent(SUPV_EVENT_BUFFER_REQUEST_SUCCESSFUL, result);
      //      } else if (result == PROCESS_TERMINATED) {
      //        // Event already triggered
      //        break;
      //      } else {
      //        triggerEvent(SUPV_EVENT_BUFFER_REQUEST_FAILED, result);
      //      }
      break;
    }
    case Request::DEFAULT: {
@ -974,7 +962,7 @@ ReturnValue_t PlocSupvUartManager::handleRunningLongerRequest() {
 ReturnValue_t PlocSupvUartManager::encodeAndSendPacket(const uint8_t* sendData, size_t sendLen) {
  size_t encodedLen = 0;
  addHdlcFraming(sendData, sendLen, encodedSendBuf.data(), &encodedLen, encodedSendBuf.size());
-  if (PRINT_TC) {
+  if (printTc) {
    sif::debug << "Sending TC" << std::endl;
    arrayprinter::print(encodedSendBuf.data(), encodedLen);
  }
@ -996,9 +984,6 @@ ReturnValue_t PlocSupvUartManager::readReceivedMessage(CookieIF* cookie, uint8_t
    return OK;
  }
  ipcQueue.retrieve(size);
  if (*size > ipcBuffer.size()) {
    return FAILED;
  }
  *buffer = ipcBuffer.data();
  ReturnValue_t result = ipcRingBuf.readData(ipcBuffer.data(), *size, true);
  if (result != OK) {
@ -1069,7 +1054,6 @@ ReturnValue_t PlocSupvUartManager::parseRecRingBufForHdlc(size_t& readSize, size
          triggerEvent(HDLC_CRC_ERROR);
        }
        if (retval != 0) {
          readSize = ++idx;
          return HDLC_ERROR;
        }
        return returnvalue::OK;
@ -1100,14 +1084,11 @@ void PlocSupvUartManager::performUartShutdown() {
  while (not decodedQueue.empty()) {
    decodedQueue.pop();
  }
-  {
+  MutexGuard mg(ipcLock);
-    MutexGuard mg0(ipcLock);
+  ipcRingBuf.clear();
-    ipcRingBuf.clear();
+  while (not ipcQueue.empty()) {
-    while (not ipcQueue.empty()) {
+    ipcQueue.pop();
      ipcQueue.pop();
    }
  }
  MutexGuard mg1(lock);
  state = InternalState::GO_TO_SLEEP;
 }
--- a/linux/payload/PlocSupvUartMan.h
+++ b/linux/payload/PlocSupvUartMan.h
@ -16,6 +16,7 @@
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw_hal/linux/serial/SerialComIF.h"
 #include "tas/crc.h"
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/SdCardManager.h"
@ -118,35 +119,8 @@ class PlocSupvUartManager : public DeviceCommunicationIF,
  static constexpr Event HDLC_FRAME_REMOVAL_ERROR = MAKE_EVENT(31, severity::INFO);
  static constexpr Event HDLC_CRC_ERROR = MAKE_EVENT(32, severity::INFO);
  static constexpr unsigned MAX_RETRY_COUNT = 3;
  PlocSupvUartManager(object_id_t objectId);
  virtual ~PlocSupvUartManager();
  /**
   * @brief Device specific initialization, using the cookie.
   * @details
   * The cookie is already prepared in the factory. If the communication
   * interface needs to be set up in some way and requires cookie information,
   * this can be performed in this function, which is called on device handler
   * initialization.
   * @param cookie
   * @return
   *  - @c returnvalue::OK if initialization was successfull
   *  - Everything else triggers failure event with returnvalue as parameter 1
   */
  ReturnValue_t initializeInterface(CookieIF* cookie) override;
  /**
   * Called by DHB in the SEND_WRITE doSendWrite().
   * This function is used to send data to the physical device
   * by implementing and calling related drivers or wrapper functions.
   * @param cookie
   * @param data
   * @param len If this is 0, nothing shall be sent.
   * @return
   *  - @c returnvalue::OK for successfull send
   *  - Everything else triggers failure event with returnvalue as parameter 1
   */
  ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
  ReturnValue_t readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) override;
  ReturnValue_t initialize() override;
  ReturnValue_t performOperation(uint8_t operationCode = 0) override;
@ -200,8 +174,6 @@ class PlocSupvUartManager : public DeviceCommunicationIF,
  static constexpr ReturnValue_t POSSIBLE_PACKET_LOSS_CONSECUTIVE_END = returnvalue::makeCode(1, 4);
  static constexpr ReturnValue_t HDLC_ERROR = returnvalue::makeCode(1, 5);
  static constexpr uint32_t COM_TIMEOUT_MS = 3000;
  static const uint16_t CRC16_INIT = 0xFFFF;
  // Event buffer reply will carry 24 space packets with 1016 bytes and one space packet with
  // 192 bytes
@ -234,11 +206,11 @@ class PlocSupvUartManager : public DeviceCommunicationIF,
  struct Update update;
  int serialPort = 0;
  SemaphoreIF* semaphore;
  MutexIF* lock;
  MutexIF* ipcLock;
  supv::TmBase tmReader;
  int serialPort = 0;
  struct termios tty = {};
 #if OBSW_THREAD_TRACING == 1
  uint32_t opCounter = 0;
@ -285,8 +257,8 @@ class PlocSupvUartManager : public DeviceCommunicationIF,
  std::array<uint8_t, supv::MAX_COMMAND_SIZE> tmBuf{};
-  static constexpr bool PRINT_TC = false;
+  bool printTc = false;
-  static constexpr bool DEBUG_MODE = false;
+  bool debugMode = false;
  bool timestamping = true;
  // Remembers APID to know at which command a procedure failed
@ -347,6 +319,32 @@ class PlocSupvUartManager : public DeviceCommunicationIF,
  void resetSpParams();
  void pushIpcData(const uint8_t* data, size_t len);
  /**
   * @brief Device specific initialization, using the cookie.
   * @details
   * The cookie is already prepared in the factory. If the communication
   * interface needs to be set up in some way and requires cookie information,
   * this can be performed in this function, which is called on device handler
   * initialization.
   * @param cookie
   * @return
   *  - @c returnvalue::OK if initialization was successfull
   *  - Everything else triggers failure event with returnvalue as parameter 1
   */
  ReturnValue_t initializeInterface(CookieIF* cookie) override;
  /**
   * Called by DHB in the SEND_WRITE doSendWrite().
   * This function is used to send data to the physical device
   * by implementing and calling related drivers or wrapper functions.
   * @param cookie
   * @param data
   * @param len If this is 0, nothing shall be sent.
   * @return
   *  - @c returnvalue::OK for successfull send
   *  - Everything else triggers failure event with returnvalue as parameter 1
   */
  ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
  /**
   * Called by DHB in the GET_WRITE doGetWrite().
   * Get send confirmation that the data in sendMessage() was sent successfully.
@ -371,8 +369,7 @@ class PlocSupvUartManager : public DeviceCommunicationIF,
   *           returnvalue as parameter 1
   */
  ReturnValue_t requestReceiveMessage(CookieIF* cookie, size_t requestLen) override;
-
+  ReturnValue_t readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) override;
  ReturnValue_t writeMemoryHandlingWithRetryLogic(supv::WriteMemory& packet, unsigned progPercent);
  void performUartShutdown();
  void updateVtime(uint8_t vtime);
--- a/linux/payload/SerialCommunicationHelper.cpp
+++ b/linux/payload/SerialCommunicationHelper.cpp
@ -1,126 +0,0 @@
 #include "SerialCommunicationHelper.h"
 #include <errno.h>
 #include <fcntl.h>
 #include <termios.h>
 #include <unistd.h>
 #include <cstring>
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw_hal/linux/serial/helper.h"
 SerialCommunicationHelper::SerialCommunicationHelper(SerialConfig cfg) : cfg(cfg) {}
 ReturnValue_t SerialCommunicationHelper::initialize() {
  fd = configureUartPort();
  if (fd < 0) {
    return returnvalue::FAILED;
  }
  return returnvalue::OK;
 }
 int SerialCommunicationHelper::rawFd() const { return fd; }
 ReturnValue_t SerialCommunicationHelper::send(const uint8_t* data, size_t dataLen) {
  if (write(fd, data, dataLen) != static_cast<int>(dataLen)) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::error << "UartComIF::sendMessage: Failed to send data with error code " << errno
               << ": Error description: " << strerror(errno) << std::endl;
 #endif
    return returnvalue::FAILED;
  }
  return returnvalue::OK;
 }
 int SerialCommunicationHelper::configureUartPort() {
  struct termios options = {};
  int flags = O_RDWR;
  if (cfg.getUartMode() == UartModes::CANONICAL) {
    // In non-canonical mode, don't specify O_NONBLOCK because these properties will be
    // controlled by the VTIME and VMIN parameters and O_NONBLOCK would override this
    flags |= O_NONBLOCK;
  }
  int fd = open(cfg.getDeviceFile().c_str(), flags);
  if (fd < 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "UartComIF::configureUartPort: Failed to open uart "
                 << cfg.getDeviceFile().c_str()
                 << "with error code " << errno << strerror(errno) << std::endl;
 #endif
    return fd;
  }
  /* Read in existing settings */
  if (tcgetattr(fd, &options) != 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "UartComIF::configureUartPort: Error " << errno
                 << "from tcgetattr: " << strerror(errno) << std::endl;
 #endif
    return fd;
  }
  serial::setParity(options, cfg.getParity());
  serial::setStopbits(options, cfg.getStopBits());
  serial::setBitsPerWord(options, cfg.getBitsPerWord());
  setFixedOptions(&options);
  serial::setMode(options, cfg.getUartMode());
  tcflush(fd, TCIFLUSH);
  /* Sets uart to non-blocking mode. Read returns immediately when there are no data available */
  options.c_cc[VTIME] = 0;
  options.c_cc[VMIN] = 0;
  serial::setBaudrate(options, cfg.getBaudrate());
  /* Save option settings */
  if (tcsetattr(fd, TCSANOW, &options) != 0) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
    sif::warning << "UartComIF::configureUartPort: Failed to set options with error " << errno
                 << ": " << strerror(errno);
 #endif
    return fd;
  }
  return fd;
 }
 void SerialCommunicationHelper::setFixedOptions(struct termios* options) {
  /* Disable RTS/CTS hardware flow control */
  options->c_cflag &= ~CRTSCTS;
  /* Turn on READ & ignore ctrl lines (CLOCAL = 1) */
  options->c_cflag |= CREAD | CLOCAL;
  /* Disable echo */
  options->c_lflag &= ~ECHO;
  /* Disable erasure */
  options->c_lflag &= ~ECHOE;
  /* Disable new-line echo */
  options->c_lflag &= ~ECHONL;
  /* Disable interpretation of INTR, QUIT and SUSP */
  options->c_lflag &= ~ISIG;
  /* Turn off s/w flow ctrl */
  options->c_iflag &= ~(IXON | IXOFF | IXANY);
  /* Disable any special handling of received bytes */
  options->c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL);
  /* Prevent special interpretation of output bytes (e.g. newline chars) */
  options->c_oflag &= ~OPOST;
  /* Prevent conversion of newline to carriage return/line feed */
  options->c_oflag &= ~ONLCR;
 }
 ReturnValue_t SerialCommunicationHelper::flushUartRxBuffer() {
  serial::flushRxBuf(fd);
  return returnvalue::OK;
 }
 ReturnValue_t SerialCommunicationHelper::flushUartTxBuffer() {
  serial::flushTxBuf(fd);
  return returnvalue::OK;
 }
 ReturnValue_t SerialCommunicationHelper::flushUartTxAndRxBuf() {
  serial::flushTxRxBuf(fd);
  return returnvalue::OK;
 }
--- a/linux/payload/SerialCommunicationHelper.h
+++ b/linux/payload/SerialCommunicationHelper.h
@ -1,69 +0,0 @@
 #pragma once
 #include <fsfw/devicehandlers/DeviceCommunicationIF.h>
 #include <fsfw/objectmanager/SystemObject.h>
 #include <fsfw_hal/linux/serial/SerialCookie.h>
 #include <fsfw_hal/linux/serial/helper.h>
 #include "SerialConfig.h"
 #include "fsfw/returnvalues/returnvalue.h"
 /**
 * @brief 	This is the communication interface to access serial ports on linux based operating
 *          systems.
 *
 * @details The implementation follows the instructions from https://blog.mbedded.ninja/programming/
 *          operating-systems/linux/linux-serial-ports-using-c-cpp/#disabling-canonical-mode
 *
 * @author 	J. Meier
 */
 class SerialCommunicationHelper {
 public:
  SerialCommunicationHelper(SerialConfig serialCfg);
  ReturnValue_t send(const uint8_t* data, size_t dataLen);
  int rawFd() const;
  ReturnValue_t initialize();
  /**
   * @brief   This function discards all data received but not read in the UART buffer.
   */
  ReturnValue_t flushUartRxBuffer();
  /**
   * @brief   This function discards all data in the transmit buffer of the UART driver.
   */
  ReturnValue_t flushUartTxBuffer();
  /**
   * @brief   This function discards both data in the transmit and receive buffer of the UART.
   */
  ReturnValue_t flushUartTxAndRxBuf();
 private:
  SerialConfig cfg;
  int fd = 0;
  /**
   * @brief	This function opens and configures a uart device by using the information stored
   *          in the uart cookie.
   * @param uartCookie    Pointer to uart cookie with information about the uart. Contains the
   *                      uart device file, baudrate, parity, stopbits etc.
   * @return  The file descriptor of the configured uart.
   */
  int configureUartPort();
  void setStopBitOptions(struct termios* options);
  /**
   * @brief   This function sets options which are not configurable by the uartCookie.
   */
  void setFixedOptions(struct termios* options);
  /**
   * @brief   With this function the datasize settings are added to the termios options struct.
   */
  void setDatasizeOptions(struct termios* options);
 };
--- a/linux/payload/SerialConfig.h
+++ b/linux/payload/SerialConfig.h
@ -1,70 +0,0 @@
 #pragma once
 #include <fsfw/devicehandlers/CookieIF.h>
 #include <fsfw/objectmanager/SystemObjectIF.h>
 #include <fsfw_hal/linux/serial/helper.h>
 #include <string>
 /**
 * @brief   Cookie for the UartComIF. There are many options available to configure the UART driver.
 *          The constructor only requests for common options like the baudrate. Other options can
 *          be set by member functions.
 *
 * @author 	J. Meier
 */
 class SerialConfig : public CookieIF {
 public:
  /**
   * @brief	Constructor for the uart cookie.
   * @param deviceFile    The device file specifying the uart to use, e.g. "/dev/ttyPS1"
   * @param uartMode      Specify the UART mode. The canonical mode should be used if the
   *                      messages are separated by a delimited character like '\n'. See the
   *                      termios documentation for more information
   * @param baudrate      The baudrate to use for input and output.
   * @param maxReplyLen   The maximum size an object using this cookie expects
   * @details
   * Default configuration: No parity
   *                        8 databits (number of bits transfered with one uart frame)
   *                        One stop bit
   */
  SerialConfig(std::string deviceFile, UartBaudRate baudrate, size_t maxReplyLen,
               UartModes uartMode = UartModes::NON_CANONICAL)
      : deviceFile(deviceFile), baudrate(baudrate), maxReplyLen(maxReplyLen), uartMode(uartMode) {}
  virtual ~SerialConfig() = default;
  UartBaudRate getBaudrate() const { return baudrate; }
  size_t getMaxReplyLen() const { return maxReplyLen; }
  std::string getDeviceFile() const { return deviceFile; }
  Parity getParity() const { return parity; }
  BitsPerWord getBitsPerWord() const { return bitsPerWord; }
  StopBits getStopBits() const { return stopBits; }
  UartModes getUartMode() const { return uartMode; }
  /**
   * Functions two enable parity checking.
   */
  void setParityOdd() { parity = Parity::ODD; }
  void setParityEven() { parity = Parity::EVEN; }
  /**
   * Function two set number of bits per UART frame.
   */
  void setBitsPerWord(BitsPerWord bitsPerWord_) { bitsPerWord = bitsPerWord_; }
  /**
   * Function to specify the number of stopbits.
   */
  void setTwoStopBits() { stopBits = StopBits::TWO_STOP_BITS; }
  void setOneStopBit() { stopBits = StopBits::ONE_STOP_BIT; }
 private:
  std::string deviceFile;
  UartBaudRate baudrate;
  size_t maxReplyLen = 0;
  const UartModes uartMode;
  Parity parity = Parity::NONE;
  BitsPerWord bitsPerWord = BitsPerWord::BITS_8;
  StopBits stopBits = StopBits::ONE_STOP_BIT;
 };
--- a/linux/payload/mpsocRetvals.h
+++ b/linux/payload/mpsocRetvals.h
@ -0,0 +1,33 @@
 #ifndef MPSOC_RETURN_VALUES_IF_H_
 #define MPSOC_RETURN_VALUES_IF_H_
 #include "eive/resultClassIds.h"
 #include "fsfw/returnvalues/returnvalue.h"
 class MPSoCReturnValuesIF {
 public:
  static const uint8_t INTERFACE_ID = CLASS_ID::MPSOC_RETURN_VALUES_IF;
  //! [EXPORT] : [COMMENT] Space Packet received from PLOC has invalid CRC
  static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0);
  //! [EXPORT] : [COMMENT] Received ACK failure reply from PLOC
  static const ReturnValue_t RECEIVED_ACK_FAILURE = MAKE_RETURN_CODE(0xA1);
  //! [EXPORT] : [COMMENT] Received execution failure reply from PLOC
  static const ReturnValue_t RECEIVED_EXE_FAILURE = MAKE_RETURN_CODE(0xA2);
  //! [EXPORT] : [COMMENT] Received space packet with invalid APID from PLOC
  static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3);
  //! [EXPORT] : [COMMENT] Received command with invalid length
  static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xA4);
  //! [EXPORT] : [COMMENT] Filename of file in OBC filesystem is too long
  static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA5);
  //! [EXPORT] : [COMMENT] MPSoC helper is currently executing a command
  static const ReturnValue_t MPSOC_HELPER_EXECUTING = MAKE_RETURN_CODE(0xA6);
  //! [EXPORT] : [COMMENT] Filename of MPSoC file is to long (max. 256 bytes)
  static const ReturnValue_t MPSOC_FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA7);
  //! [EXPORT] : [COMMENT] Command has invalid parameter
  static const ReturnValue_t INVALID_PARAMETER = MAKE_RETURN_CODE(0xA8);
  //! [EXPORT] : [COMMENT] Received command has file string with invalid length
  static const ReturnValue_t NAME_TOO_LONG = MAKE_RETURN_CODE(0xA9);
 };
 #endif /* MPSOC_RETURN_VALUES_IF_H_ */
--- a/linux/payload/plocMpsocHelpers.cpp
+++ b/linux/payload/plocMpsocHelpers.cpp
@ -1,94 +1,87 @@
 #include "plocMpsocHelpers.h"
 #include "fsfw/tmtcpacket/ccsds/SpacePacketReader.h"
 #include "mission/payload/plocSpBase.h"
 uint16_t mpsoc::getStatusFromRawData(const uint8_t* data) {
  return (*(data + STATUS_OFFSET) << 8) | *(data + STATUS_OFFSET + 1);
 }
 std::string mpsoc::getStatusString(uint16_t status) {
  switch (status) {
-    case (mpsoc::statusCode::UNKNOWN_APID): {
+    case (mpsoc::status_code::UNKNOWN_APID): {
      return "Unknown APID";
      break;
    }
-    case (mpsoc::statusCode::INCORRECT_LENGTH): {
+    case (mpsoc::status_code::INCORRECT_LENGTH): {
      return "Incorrect length";
      break;
    }
-    case (mpsoc::statusCode::FLASH_DRIVE_ERROR): {
+    case (mpsoc::status_code::INCORRECT_CRC): {
      return "flash drive error";
      break;
    }
    case (mpsoc::statusCode::INCORRECT_CRC): {
      return "Incorrect crc";
      break;
    }
-    case (mpsoc::statusCode::INCORRECT_PKT_SEQ_CNT): {
+    case (mpsoc::status_code::INCORRECT_PKT_SEQ_CNT): {
      return "Incorrect packet sequence count";
      break;
    }
-    case (mpsoc::statusCode::TC_NOT_ALLOWED_IN_MODE): {
+    case (mpsoc::status_code::TC_NOT_ALLOWED_IN_MODE): {
      return "TC not allowed in this mode";
      break;
    }
-    case (mpsoc::statusCode::TC_EXEUTION_DISABLED): {
+    case (mpsoc::status_code::TC_EXEUTION_DISABLED): {
      return "TC execution disabled";
      break;
    }
-    case (mpsoc::statusCode::FLASH_MOUNT_FAILED): {
+    case (mpsoc::status_code::FLASH_MOUNT_FAILED): {
      return "Flash mount failed";
      break;
    }
-    case (mpsoc::statusCode::FLASH_FILE_ALREADY_OPEN): {
+    case (mpsoc::status_code::FLASH_FILE_ALREADY_OPEN): {
      return "Flash file already open";
      break;
    }
-    case (mpsoc::statusCode::FLASH_FILE_ALREADY_CLOSED): {
+    case (mpsoc::status_code::FLASH_FILE_ALREADY_CLOSED): {
      return "Flash file already closed";
      break;
    }
-    case (mpsoc::statusCode::FLASH_FILE_OPEN_FAILED): {
+    case (mpsoc::status_code::FLASH_FILE_OPEN_FAILED): {
      return "Flash file open failed";
      break;
    }
-    case (mpsoc::statusCode::FLASH_FILE_NOT_OPEN): {
+    case (mpsoc::status_code::FLASH_FILE_NOT_OPEN): {
      return "Flash file not open";
      break;
    }
-    case (mpsoc::statusCode::FLASH_UNMOUNT_FAILED): {
+    case (mpsoc::status_code::FLASH_UNMOUNT_FAILED): {
      return "Flash unmount failed";
      break;
    }
-    case (mpsoc::statusCode::HEAP_ALLOCATION_FAILED): {
+    case (mpsoc::status_code::HEAP_ALLOCATION_FAILED): {
      return "Heap allocation failed";
      break;
    }
-    case (mpsoc::statusCode::INVALID_PARAMETER): {
+    case (mpsoc::status_code::INVALID_PARAMETER): {
      return "Invalid parameter";
      break;
    }
-    case (mpsoc::statusCode::NOT_INITIALIZED): {
+    case (mpsoc::status_code::NOT_INITIALIZED): {
      return "Not initialized";
      break;
    }
-    case (mpsoc::statusCode::REBOOT_IMMINENT): {
+    case (mpsoc::status_code::REBOOT_IMMINENT): {
      return "Reboot imminent";
      break;
    }
-    case (mpsoc::statusCode::CORRUPT_DATA): {
+    case (mpsoc::status_code::CORRUPT_DATA): {
      return "Corrupt data";
      break;
    }
-    case (mpsoc::statusCode::FLASH_CORRECTABLE_MISMATCH): {
+    case (mpsoc::status_code::FLASH_CORRECTABLE_MISMATCH): {
      return "Flash correctable mismatch";
      break;
    }
-    case (mpsoc::statusCode::FLASH_UNCORRECTABLE_MISMATCH): {
+    case (mpsoc::status_code::FLASH_UNCORRECTABLE_MISMATCH): {
      return "Flash uncorrectable mismatch";
      break;
    }
-    case (mpsoc::statusCode::DEFAULT_ERROR_CODE): {
+    case (mpsoc::status_code::DEFAULT_ERROR_CODE): {
      return "Default error code";
      break;
    }
@ -100,19 +93,3 @@ std::string mpsoc::getStatusString(uint16_t status) {
  }
  return "";
 }
 void mpsoc::printRxPacket(const SpacePacketReader& spReader) {
  if (mpsoc::MPSOC_RX_WIRETAPPING) {
    sif::debug << "RECV MPSOC packet. APID 0x" << std::hex << std::setw(3) << spReader.getApid()
               << std::dec << " Size " << spReader.getFullPacketLen() << " SSC "
               << spReader.getSequenceCount() << std::endl;
  }
 }
 void mpsoc::printTxPacket(const ploc::SpTcBase& tcBase) {
  if (mpsoc::MPSOC_TX_WIRETAPPING) {
    sif::debug << "SEND MPSOC packet. APID 0x" << std::hex << std::setw(3) << tcBase.getApid()
               << " Size " << std::dec << tcBase.getFullPacketLen() << " SSC "
               << tcBase.getSeqCount() << std::endl;
  }
 }
--- a/linux/payload/plocMpsocHelpers.h
+++ b/linux/payload/plocMpsocHelpers.h
@ -3,124 +3,16 @@
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
 #include <fsfw/devicehandlers/DeviceHandlerIF.h>
 #include <linux/payload/mpsocRetvals.h>
 #include <mission/payload/plocSpBase.h>
-#include "eive/eventSubsystemIds.h"
+#include "OBSWConfig.h"
-#include "eive/resultClassIds.h"
+#include "eive/definitions.h"
-#include "fsfw/action/HasActionsIF.h"
+#include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/events/Event.h"
 #include "fsfw/returnvalues/returnvalue.h"
 #include "fsfw/serialize/SerializeAdapter.h"
 #include "fsfw/serialize/SerializeIF.h"
 namespace mpsoc {
 static constexpr bool MPSOC_TX_WIRETAPPING = false;
 static constexpr bool MPSOC_RX_WIRETAPPING = false;
 static constexpr size_t CRC_SIZE = 2;
 /**
 * @brief   Abstract base class for TC space packet of MPSoC.
 */
 class TcBase : public ploc::SpTcBase {
 public:
  virtual ~TcBase() = default;
  // Initial length field of space packet. Will always be updated when packet is created.
  static const uint16_t INIT_LENGTH = CRC_SIZE;
  /**
   * @brief    Constructor
   *
   * @param sequenceCount Sequence count of space packet which will be incremented with each
   *        sent and received packets.
   */
  TcBase(ploc::SpTcParams params, uint16_t apid, uint16_t sequenceCount)
      : ploc::SpTcBase(params, apid, 0, sequenceCount) {
    payloadStart = spParams.buf + ccsds::HEADER_LEN;
    spParams.setFullPayloadLen(INIT_LENGTH);
  }
  /**
   * @brief   Function to finsh and write the space packet. It is expected that the user has
   * set the payload fields in the child class*
   * @return  returnvalue::OK if packet creation was successful, otherwise error return value
   */
  ReturnValue_t finishPacket() {
    updateSpFields();
    ReturnValue_t res = checkSizeAndSerializeHeader();
    if (res != returnvalue::OK) {
      return res;
    }
    return calcAndSetCrc();
  }
 };
 void printRxPacket(const SpacePacketReader& spReader);
 void printTxPacket(const ploc::SpTcBase& tcBase);
 static constexpr uint32_t DEFAULT_CMD_TIMEOUT_MS = 5000;
 static constexpr uint32_t CMD_TIMEOUT_MKFS = 15000;
 enum FlashId : uint8_t { FLASH_0 = 0, FLASH_1 = 1 };
 static const uint8_t INTERFACE_ID = CLASS_ID::MPSOC_RETURN_VALUES_IF;
 //! [EXPORT] : [COMMENT] Space Packet received from PLOC has invalid CRC
 static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA0);
 //! [EXPORT] : [COMMENT] Received ACK failure reply from PLOC
 static const ReturnValue_t RECEIVED_ACK_FAILURE = MAKE_RETURN_CODE(0xA1);
 //! [EXPORT] : [COMMENT] Received execution failure reply from PLOC
 static const ReturnValue_t RECEIVED_EXE_FAILURE = MAKE_RETURN_CODE(0xA2);
 //! [EXPORT] : [COMMENT] Received space packet with invalid APID from PLOC
 static const ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(0xA3);
 //! [EXPORT] : [COMMENT] Received command with invalid length
 static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xA4);
 //! [EXPORT] : [COMMENT] Filename of file in OBC filesystem is too long
 static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA5);
 //! [EXPORT] : [COMMENT] MPSoC helper is currently executing a command
 static const ReturnValue_t MPSOC_HELPER_EXECUTING = MAKE_RETURN_CODE(0xA6);
 //! [EXPORT] : [COMMENT] Filename of MPSoC file is to long (max. 256 bytes)
 static const ReturnValue_t MPSOC_FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA7);
 //! [EXPORT] : [COMMENT] Command has invalid parameter
 static const ReturnValue_t INVALID_PARAMETER = MAKE_RETURN_CODE(0xA8);
 //! [EXPORT] : [COMMENT] Received command has file string with invalid length
 static const ReturnValue_t NAME_TOO_LONG = MAKE_RETURN_CODE(0xA9);
 //! [EXPORT] : [COMMENT] Command has timed out.
 static const ReturnValue_t COMMAND_TIMEOUT = MAKE_RETURN_CODE(0x10);
 static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_MPSOC_HANDLER;
 //! [EXPORT] : [COMMENT] PLOC crc failure in telemetry packet
 static const Event MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW);
 //! [EXPORT] : [COMMENT] PLOC receive acknowledgment failure report
 //! P1: Command Id which leads the acknowledgment failure report
 //! P2: The status field inserted by the MPSoC into the data field
 static const Event ACK_FAILURE = MAKE_EVENT(2, severity::LOW);
 //! [EXPORT] : [COMMENT] PLOC receive execution failure report
 //! P1: Command Id which leads the execution failure report
 //! P2: The status field inserted by the MPSoC into the data field
 static const Event EXE_FAILURE = MAKE_EVENT(3, severity::LOW);
 //! [EXPORT] : [COMMENT] PLOC reply has invalid crc
 static const Event MPSOC_HANDLER_CRC_FAILURE = MAKE_EVENT(4, severity::LOW);
 //! [EXPORT] : [COMMENT] Packet sequence count in received space packet does not match expected
 //! count P1: Expected sequence count P2: Received sequence count
 static const Event MPSOC_HANDLER_SEQUENCE_COUNT_MISMATCH = MAKE_EVENT(5, severity::LOW);
 //! [EXPORT] : [COMMENT] Supervisor fails to shutdown MPSoC. Requires to power off the PLOC and
 //! thus also to shutdown the supervisor.
 static const Event MPSOC_SHUTDOWN_FAILED = MAKE_EVENT(6, severity::HIGH);
 //! [EXPORT] : [COMMENT] SUPV not on for boot or shutdown process. P1: 0 for OFF transition, 1 for
 //! ON transition.
 static constexpr Event SUPV_NOT_ON = event::makeEvent(SUBSYSTEM_ID, 7, severity::LOW);
 //! [EXPORT] : [COMMENT] SUPV reply timeout.
 static constexpr Event SUPV_REPLY_TIMEOUT = event::makeEvent(SUBSYSTEM_ID, 8, severity::LOW);
 //! [EXPORT] : [COMMENT] Camera must be commanded on first.
 static constexpr Event CAM_MUST_BE_ON_FOR_SNAPSHOT_MODE =
    event::makeEvent(SUBSYSTEM_ID, 9, severity::LOW);
 enum ParamId : uint8_t { SKIP_SUPV_ON_COMMANDING = 0x01 };
 enum FileAccessModes : uint8_t {
  // Opens a file, fails if the file does not exist.
  OPEN_EXISTING = 0x00,
@ -136,8 +28,6 @@ enum FileAccessModes : uint8_t {
 };
 static constexpr uint32_t HK_SET_ID = 0;
 static constexpr uint32_t DEADBEEF_ADDR = 0x40000004;
 static constexpr uint32_t DEADBEEF_VALUE = 0xdeadbeef;
 namespace poolid {
 enum {
@ -200,8 +90,7 @@ 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;
 static const DeviceCommandId_t TC_CAM_TAKE_PIC = 22;
-// Stream file down using E-Band component directly.
+static const DeviceCommandId_t TC_SIMPLEX_SEND_FILE = 23;
 static const DeviceCommandId_t TC_SIMPLEX_STREAM_FILE = 23;
 static const DeviceCommandId_t TC_DOWNLINK_DATA_MODULATE = 24;
 static const DeviceCommandId_t TC_MODE_SNAPSHOT = 25;
 static const DeviceCommandId_t TC_GET_HK_REPORT = 26;
@ -209,31 +98,16 @@ static const DeviceCommandId_t TM_GET_HK_REPORT = 27;
 static const DeviceCommandId_t TC_FLASH_GET_DIRECTORY_CONTENT = 28;
 static const DeviceCommandId_t TM_FLASH_DIRECTORY_CONTENT = 29;
 static constexpr DeviceCommandId_t TC_FLASH_READ_FULL_FILE = 30;
 // Store file on MPSoC.
 static const DeviceCommandId_t TC_SPLIT_FILE = 31;
 static const DeviceCommandId_t TC_VERIFY_BOOT = 32;
 static const DeviceCommandId_t TC_ENABLE_TC_EXECTION = 33;
 static const DeviceCommandId_t TC_FLASH_MKFS = 34;
-// Will reset the sequence count of the OBSW. Not required anymore after MPSoC update.
+// Will reset the sequence count of the OBSW
-static const DeviceCommandId_t OBSW_RESET_SEQ_COUNT_LEGACY = 50;
+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;
 static constexpr size_t SIZE_TM_HK_REPORT = 369;
 enum Submode : uint8_t { IDLE_OR_NONE = 0, REPLAY = 1, SNAPSHOT = 2 };
 // Setting the internal mode value to the actual telecommand ID
 /*
 enum InternalMode {
  OFF = HasModesIF::MODE_OFF,
  IDLE = ,
  REPLAY = TC_MODE_REPLAY,
  SNAPSHOT = TC_MODE_SNAPSHOT
 };
 */
 /**
 * SpacePacket apids of PLOC telecommands and telemetry.
 */
@ -258,8 +132,6 @@ static const uint16_t TC_MODE_SNAPSHOT = 0x120;
 static const uint16_t TC_DOWNLINK_DATA_MODULATE = 0x121;
 static constexpr uint16_t TC_HK_GET_REPORT = 0x123;
 static const uint16_t TC_DOWNLINK_PWR_OFF = 0x124;
 static constexpr uint16_t TC_ENABLE_TC_EXECUTION = 0x129;
 static constexpr uint16_t TC_FLASH_MKFS = 0x12A;
 static const uint16_t TC_CAM_CMD_SEND = 0x12C;
 static constexpr uint16_t TC_FLASH_COPY_FILE = 0x12E;
 static const uint16_t TC_SIMPLEX_SEND_FILE = 0x130;
@ -284,15 +156,15 @@ static const uint8_t SPACE_PACKET_HEADER_SIZE = 6;
 static const uint8_t STATUS_OFFSET = 10;
 static constexpr size_t CRC_SIZE = 2;
 /**
 * 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 FILENAME_FIELD_SIZE = 256;
+static const size_t MAX_FILENAME_SIZE = 256;
 // Subtract size of NULL terminator.
 static const size_t MAX_FILENAME_SIZE = FILENAME_FIELD_SIZE - 1;
 /**
 * PLOC space packet length for fixed size packets. This is the size of the whole packet data
@ -327,9 +199,8 @@ static const uint16_t TC_DOWNLINK_PWR_ON_EXECUTION_DELAY = 8;
 static const uint16_t TC_CAM_TAKE_PIC_EXECUTION_DELAY = 20;
 static const uint16_t TC_SIMPLEX_SEND_FILE_DELAY = 80;
-namespace statusCode {
+namespace status_code {
 static const uint16_t DEFAULT_ERROR_CODE = 0x1;
 static constexpr uint16_t FLASH_DRIVE_ERROR = 0xb;
 static const uint16_t UNKNOWN_APID = 0x5DD;
 static const uint16_t INCORRECT_LENGTH = 0x5DE;
 static const uint16_t INCORRECT_CRC = 0x5DF;
@ -354,12 +225,49 @@ 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 statusCode
+}  // namespace status_code
 /**
 * @brief   Abstract base class for TC space packet of MPSoC.
 */
 class TcBase : public ploc::SpTcBase, public MPSoCReturnValuesIF {
 public:
  virtual ~TcBase() = default;
  // Initial length field of space packet. Will always be updated when packet is created.
  static const uint16_t INIT_LENGTH = CRC_SIZE;
  /**
   * @brief    Constructor
   *
   * @param sequenceCount Sequence count of space packet which will be incremented with each
   *        sent and received packets.
   */
  TcBase(ploc::SpTcParams params, uint16_t apid, uint16_t sequenceCount)
      : ploc::SpTcBase(params, apid, 0, sequenceCount) {
    payloadStart = spParams.buf + ccsds::HEADER_LEN;
    spParams.setFullPayloadLen(INIT_LENGTH);
  }
  /**
   * @brief   Function to finsh and write the space packet. It is expected that the user has
   * set the payload fields in the child class*
   * @return  returnvalue::OK if packet creation was successful, otherwise error return value
   */
  ReturnValue_t finishPacket() {
    updateSpFields();
    ReturnValue_t res = checkSizeAndSerializeHeader();
    if (res != returnvalue::OK) {
      return res;
    }
    return calcAndSetCrc();
  }
 };
 /**
 * @brief   This class helps to build the memory read command for the PLOC.
 */
-class TcMemRead : public mpsoc::TcBase {
+class TcMemRead : public TcBase {
 public:
  /**
   * @brief   Constructor
@ -409,7 +317,7 @@ class TcMemRead : public mpsoc::TcBase {
 * @brief   This class helps to generate the space packet to write data to a memory address within
 *          the PLOC.
 */
-class TcMemWrite : public mpsoc::TcBase {
+class TcMemWrite : public TcBase {
 public:
  /**
   * @brief   Constructor
@ -459,21 +367,24 @@ class TcMemWrite : public mpsoc::TcBase {
 /**
 * @brief   Class to help creation of flash fopen command.
 */
-class TcFlashFopen : public mpsoc::TcBase {
+class FlashFopen : public TcBase {
 public:
-  TcFlashFopen(ploc::SpTcParams params, uint16_t sequenceCount)
+  FlashFopen(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_FLASHFOPEN, sequenceCount) {}
  ReturnValue_t setPayload(std::string filename, uint8_t mode) {
    accessMode = mode;
    size_t nameSize = filename.size();
    spParams.setFullPayloadLen(256 + sizeof(uint8_t) + CRC_SIZE);
    ReturnValue_t result = checkPayloadLen();
    if (result != returnvalue::OK) {
      return result;
    }
-    std::memset(payloadStart, 0, FILENAME_FIELD_SIZE);
+    std::memcpy(payloadStart, filename.c_str(), nameSize);
-    std::memcpy(payloadStart, filename.c_str(), filename.size());
+    // payloadStart[nameSize] = NULL_TERMINATOR;
-    payloadStart[FILENAME_FIELD_SIZE] = accessMode;
+    std::memset(payloadStart + nameSize, 0, 256 - nameSize);
-    spParams.setFullPayloadLen(FILENAME_FIELD_SIZE + 1 + CRC_SIZE);
+    // payloadStart[255] = NULL_TERMINATOR;
    payloadStart[256] = accessMode;
    return returnvalue::OK;
  }
@ -484,46 +395,14 @@ class TcFlashFopen : public mpsoc::TcBase {
 /**
 * @brief   Class to help creation of flash fclose command.
 */
-class TcFlashFclose : public TcBase {
+class FlashFclose : public TcBase {
 public:
-  TcFlashFclose(ploc::SpTcParams params, uint16_t sequenceCount)
+  FlashFclose(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_FLASHFCLOSE, sequenceCount) {
    spParams.setFullPayloadLen(CRC_SIZE);
  }
 };
 class TcEnableTcExec : public TcBase {
 public:
  TcEnableTcExec(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_ENABLE_TC_EXECUTION, sequenceCount) {
    spParams.setFullPayloadLen(CRC_SIZE);
  }
  ReturnValue_t setPayload(const uint8_t* cmdData, size_t cmdDataLen) {
    if (cmdDataLen != 2) {
      return HasActionsIF::INVALID_PARAMETERS;
    }
    std::memcpy(payloadStart, cmdData, 2);
    spParams.setFullPayloadLen(2 + CRC_SIZE);
    return returnvalue::OK;
  }
 };
 class TcFlashMkfs : public TcBase {
 public:
  TcFlashMkfs(ploc::SpTcParams params, uint16_t sequenceCount, FlashId flashId)
      : TcBase(params, apid::TC_FLASH_MKFS, sequenceCount) {
    const char* flashIdStr = "0:\\";
    if (flashId == FlashId::FLASH_1) {
      flashIdStr = "1:\\";
    }
    std::memcpy(payloadStart, flashIdStr, 3);
    // Null terminator
    payloadStart[3] = 0;
    spParams.setFullPayloadLen(4 + CRC_SIZE);
  }
 };
 /**
 * @brief   Class to build flash write space packet.
 */
@ -583,6 +462,15 @@ class TcFlashRead : public TcBase {
    if (result != returnvalue::OK) {
      return result;
    }
    updateSpFields();
    result = checkSizeAndSerializeHeader();
    if (result != returnvalue::OK) {
      return result;
    }
    result = calcAndSetCrc();
    if (result != returnvalue::OK) {
      return result;
    }
    readSize = readLen;
    return result;
  }
@ -600,14 +488,20 @@ class TcFlashDelete : public TcBase {
  ReturnValue_t setPayload(std::string filename) {
    size_t nameSize = filename.size();
-    spParams.setFullPayloadLen(FILENAME_FIELD_SIZE + CRC_SIZE);
+    spParams.setFullPayloadLen(nameSize + sizeof(NULL_TERMINATOR) + CRC_SIZE);
    auto res = checkPayloadLen();
    if (res != returnvalue::OK) {
      return res;
    }
    std::memcpy(payloadStart, filename.c_str(), nameSize);
    *(payloadStart + nameSize) = NULL_TERMINATOR;
-    return returnvalue::OK;
+
    updateSpFields();
    res = checkSizeAndSerializeHeader();
    if (res != returnvalue::OK) {
      return res;
    }
    return calcAndSetCrc();
  }
 };
@ -759,9 +653,8 @@ class TcGetDirContent : public TcBase {
    if (result != returnvalue::OK) {
      return result;
    }
    std::memset(payloadStart, 0, 256);
    std::memcpy(payloadStart, commandData, commandDataLen);
-    payloadStart[255] = 0;
+    payloadStart[255] = '\0';
    return result;
  }
 };
@ -802,7 +695,7 @@ class TcReplayWriteSeq : public TcBase {
  static const size_t USE_DECODING_LENGTH = 1;
  ReturnValue_t lengthCheck(size_t commandDataLen) {
-    if (commandDataLen > USE_DECODING_LENGTH + FILENAME_FIELD_SIZE or
+    if (commandDataLen > USE_DECODING_LENGTH + MAX_FILENAME_SIZE or
        checkPayloadLen() != returnvalue::OK) {
      sif::warning << "TcReplayWriteSeq: Command has invalid length " << commandDataLen
                   << std::endl;
@ -815,24 +708,24 @@ class TcReplayWriteSeq : public TcBase {
 /**
 * @brief   Helps to extract the fields of the flash write command from the PUS packet.
 */
-class FlashBasePusCmd {
+class FlashBasePusCmd : public MPSoCReturnValuesIF {
 public:
  FlashBasePusCmd() = default;
  virtual ~FlashBasePusCmd() = default;
  virtual ReturnValue_t extractFields(const uint8_t* commandData, size_t commandDataLen) {
-    if (commandDataLen > FILENAME_FIELD_SIZE) {
+    if (commandDataLen > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE + MAX_FILENAME_SIZE)) {
      return INVALID_LENGTH;
    }
    size_t fileLen = strnlen(reinterpret_cast<const char*>(commandData), commandDataLen);
-    if (fileLen > MAX_FILENAME_SIZE) {
+    if (fileLen > (config::MAX_PATH_SIZE + config::MAX_FILENAME_SIZE)) {
      return FILENAME_TOO_LONG;
    }
    obcFile = std::string(reinterpret_cast<const char*>(commandData), fileLen);
    fileLen =
        strnlen(reinterpret_cast<const char*>(commandData + obcFile.size() + SIZE_NULL_TERMINATOR),
                commandDataLen - obcFile.size() - 1);
-    if (fileLen > FILENAME_FIELD_SIZE) {
+    if (fileLen > MAX_FILENAME_SIZE) {
      return MPSOC_FILENAME_TOO_LONG;
    }
    mpsocFile = std::string(
@ -843,11 +736,11 @@ class FlashBasePusCmd {
  const std::string& getObcFile() const { return obcFile; }
-  const std::string& getMpsocFile() const { return mpsocFile; }
+  const std::string& getMPSoCFile() const { return mpsocFile; }
 protected:
  size_t getParsedSize() const {
-    return getObcFile().size() + getMpsocFile().size() + 2 * SIZE_NULL_TERMINATOR;
+    return getObcFile().size() + getMPSoCFile().size() + 2 * SIZE_NULL_TERMINATOR;
  }
  static const size_t SIZE_NULL_TERMINATOR = 1;
@ -914,191 +807,49 @@ class TcCamTakePic : public TcBase {
      : TcBase(params, apid::TC_CAM_TAKE_PIC, sequenceCount) {}
  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    const uint8_t** dataPtr = &commandData;
    if (commandDataLen > FULL_PAYLOAD_SIZE) {
      return INVALID_LENGTH;
    }
    size_t deserLen = commandDataLen;
    size_t serLen = 0;
    fileName = std::string(reinterpret_cast<const char*>(commandData));
    if (fileName.size() > MAX_FILENAME_SIZE) {
      return FILENAME_TOO_LONG;
    }
    deserLen -= fileName.length() + 1;
    *dataPtr += fileName.length() + 1;
    uint8_t** payloadPtr = &payloadStart;
    memset(payloadStart, 0, FILENAME_FIELD_SIZE);
    memcpy(payloadStart, fileName.data(), fileName.size());
    *payloadPtr += FILENAME_FIELD_SIZE;
    serLen += FILENAME_FIELD_SIZE;
    ReturnValue_t result = SerializeAdapter::deSerialize(&encoderSettingY, dataPtr, &deserLen,
                                                         SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::serialize(&encoderSettingY, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
                                         SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::deSerialize(&quantizationY, dataPtr, &deserLen,
                                           SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::serialize(&quantizationY, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
                                         SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::deSerialize(&encoderSettingsCb, dataPtr, &deserLen,
                                           SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::serialize(&encoderSettingsCb, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
                                         SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::deSerialize(&quantizationCb, dataPtr, &deserLen,
                                           SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::serialize(&quantizationCb, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
                                         SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::deSerialize(&encoderSettingsCr, dataPtr, &deserLen,
                                           SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::serialize(&encoderSettingsCr, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
                                         SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::deSerialize(&quantizationCr, dataPtr, &deserLen,
                                           SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::serialize(&quantizationCr, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
                                         SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::deSerialize(&bypassCompressor, dataPtr, &deserLen,
                                           SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    result = SerializeAdapter::serialize(&bypassCompressor, payloadPtr, &serLen, FULL_PAYLOAD_SIZE,
                                         SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    spParams.setFullPayloadLen(FULL_PAYLOAD_SIZE + CRC_SIZE);
    return returnvalue::OK;
  }
  std::string fileName;
  uint8_t encoderSettingY = 7;
  uint64_t quantizationY = 0;
  uint8_t encoderSettingsCb = 7;
  uint64_t quantizationCb = 0;
  uint8_t encoderSettingsCr = 7;
  uint64_t quantizationCr = 0;
  uint8_t bypassCompressor = 0;
 private:
  static const size_t PARAMETER_SIZE = 28;
  static constexpr size_t FULL_PAYLOAD_SIZE = FILENAME_FIELD_SIZE + PARAMETER_SIZE;
 };
 /**
 * @brief   Class to build simplex send file command
 */
 class TcSimplexStreamFile : public TcBase {
 public:
  TcSimplexStreamFile(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_SIMPLEX_SEND_FILE, sequenceCount) {}
  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    if (commandDataLen > MAX_FILENAME_SIZE) {
      return INVALID_LENGTH;
    }
    std::string fileName(reinterpret_cast<const char*>(commandData));
    if (fileName.size() > MAX_FILENAME_SIZE) {
      return FILENAME_TOO_LONG;
    }
    std::memset(payloadStart, 0, FILENAME_FIELD_SIZE);
    std::memcpy(payloadStart, fileName.data(), fileName.length());
    payloadStart[fileName.length()] = 0;
    spParams.setFullPayloadLen(FILENAME_FIELD_SIZE + CRC_SIZE);
    ;
    return returnvalue::OK;
  }
 private:
 };
 /**
 * @brief   Class to build simplex send file command
 */
 class TcSplitFile : public TcBase {
 public:
  TcSplitFile(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_SIMPLEX_SEND_FILE, sequenceCount) {}
  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    if (commandDataLen < MIN_DATA_LENGTH) {
      return INVALID_LENGTH;
    }
    if (commandDataLen > MAX_DATA_LENGTH) {
      return INVALID_LENGTH;
    }
-    const uint8_t** dataPtr = &commandData;
+    std::string fileName(reinterpret_cast<const char*>(commandData));
-    ReturnValue_t result = SerializeAdapter::deSerialize(&chunkParameter, dataPtr, &commandDataLen,
+    if (fileName.size() + sizeof(NULL_TERMINATOR) > MAX_FILENAME_SIZE) {
                                                         SerializeIF::Endianness::NETWORK);
    if (result != returnvalue::OK) {
      return result;
    }
    /// No chunks makes no sense, and DIV str can not be longer than whats representable with 3
    /// decimal digits.
    if (chunkParameter == 0 or chunkParameter > 999) {
      return INVALID_PARAMETER;
    }
    std::string fileName(reinterpret_cast<const char*>(*dataPtr));
    if (fileName.size() > MAX_FILENAME_SIZE) {
      return FILENAME_TOO_LONG;
    }
-    char divStr[16]{};
+    if (commandDataLen - (fileName.size() + sizeof(NULL_TERMINATOR)) != PARAMETER_SIZE) {
-    sprintf(divStr, "DIV%03u", chunkParameter);
+      return INVALID_LENGTH;
-    std::memcpy(payloadStart, divStr, DIV_STR_LEN);
+    }
-    payloadStart[DIV_STR_LEN] = 0;
+    spParams.setFullPayloadLen(commandDataLen + CRC_SIZE);
-    std::memset(payloadStart + DIV_STR_LEN + 1, 0, FILENAME_FIELD_SIZE - DIV_STR_LEN - 1);
+    std::memcpy(payloadStart, commandData, commandDataLen);
    std::memcpy(payloadStart + DIV_STR_LEN + 1, fileName.data(), fileName.length());
    spParams.setFullPayloadLen(FILENAME_FIELD_SIZE + CRC_SIZE);
    return returnvalue::OK;
  }
 private:
-  uint32_t chunkParameter = 0;
+  static const size_t MAX_DATA_LENGTH = 286;
-  static constexpr size_t MIN_DATA_LENGTH = 4;
+  static const size_t PARAMETER_SIZE = 28;
-  static constexpr size_t DIV_STR_LEN = 6;
+};
-  static constexpr size_t MAX_DATA_LENGTH = 4 + MAX_FILENAME_SIZE;
+
 /**
 * @brief   Class to build simplex send file command
 */
 class TcSimplexSendFile : public TcBase {
 public:
  TcSimplexSendFile(ploc::SpTcParams params, uint16_t sequenceCount)
      : TcBase(params, apid::TC_SIMPLEX_SEND_FILE, sequenceCount) {}
  ReturnValue_t setPayload(const uint8_t* commandData, size_t commandDataLen) {
    if (commandDataLen > MAX_DATA_LENGTH) {
      return INVALID_LENGTH;
    }
    std::string fileName(reinterpret_cast<const char*>(commandData));
    if (fileName.size() + sizeof(NULL_TERMINATOR) > MAX_FILENAME_SIZE) {
      return FILENAME_TOO_LONG;
    }
    spParams.setFullPayloadLen(commandDataLen + CRC_SIZE);
    std::memcpy(payloadStart, commandData, commandDataLen);
    return returnvalue::OK;
  }
 private:
  static const size_t MAX_DATA_LENGTH = 256;
 };
 /**
--- a/linux/payload/plocSupvDefs.h
+++ b/linux/payload/plocSupvDefs.h
@ -10,48 +10,12 @@
 #include <fsfw/tmtcpacket/ccsds/SpacePacketReader.h>
 #include <mission/payload/plocSpBase.h>
-#include <atomic>
+#include <optional>
 #include "eive/eventSubsystemIds.h"
 #include "eive/resultClassIds.h"
 namespace supv {
 static constexpr bool DEBUG_PLOC_SUPV = false;
 static constexpr bool REDUCE_NORMAL_MODE_PRINTOUT = true;
 static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PLOC_SUPERVISOR_HANDLER;
 //! [EXPORT] : [COMMENT] PLOC supervisor crc failure in telemetry packet
 static const Event SUPV_MEMORY_READ_RPT_CRC_FAILURE = MAKE_EVENT(1, severity::LOW);
 //! [EXPORT] : [COMMENT] Unhandled event. P1: APID, P2: Service ID
 static constexpr Event SUPV_UNKNOWN_TM = MAKE_EVENT(2, severity::LOW);
 static constexpr Event SUPV_UNINIMPLEMENTED_TM = MAKE_EVENT(3, severity::LOW);
 //! [EXPORT] : [COMMENT] PLOC supervisor received acknowledgment failure report
 static const Event SUPV_ACK_FAILURE = MAKE_EVENT(4, severity::LOW);
 //! [EXPORT] : [COMMENT] PLOC received execution failure report
 //! P1: ID of command for which the execution failed
 //! P2: Status code sent by the supervisor handler
 static const Event SUPV_EXE_FAILURE = MAKE_EVENT(5, severity::LOW);
 //! [EXPORT] : [COMMENT] PLOC supervisor reply has invalid crc
 static const Event SUPV_CRC_FAILURE_EVENT = MAKE_EVENT(6, severity::LOW);
 //! [EXPORT] : [COMMENT] Supervisor helper currently executing a command
 static const Event SUPV_HELPER_EXECUTING = MAKE_EVENT(7, severity::LOW);
 //! [EXPORT] : [COMMENT] Failed to build the command to shutdown the MPSoC
 static const Event SUPV_MPSOC_SHUTDOWN_BUILD_FAILED = MAKE_EVENT(8, severity::LOW);
 //! [EXPORT] : [COMMENT] Received ACK, but no related command is unknown or has not been sent
 //  by this software instance. P1: Module APID. P2: Service ID.
 static const Event SUPV_ACK_UNKNOWN_COMMAND = MAKE_EVENT(9, severity::LOW);
 //! [EXPORT] : [COMMENT] Received ACK EXE, but no related command is unknown or has not been sent
 //  by this software instance. P1: Module APID. P2: Service ID.
 static const Event SUPV_EXE_ACK_UNKNOWN_COMMAND = MAKE_EVENT(10, severity::LOW);
 extern std::atomic_bool SUPV_ON;
 static constexpr uint32_t INTER_COMMAND_DELAY = 20;
 static constexpr uint32_t BOOT_TIMEOUT_MS = 4000;
 static constexpr uint32_t MAX_TRANSITION_TIME_TO_ON_MS = BOOT_TIMEOUT_MS + 3000;
 static constexpr uint32_t MAX_TRANSITION_TIME_TO_OFF_MS = 1000;
 namespace result {
 static const uint8_t INTERFACE_ID = CLASS_ID::SUPV_RETURN_VALUES_IF;
@ -140,7 +104,7 @@ static const DeviceCommandId_t FIRST_MRAM_DUMP = 30;
 static const DeviceCommandId_t SET_GPIO = 34;
 static const DeviceCommandId_t READ_GPIO = 35;
 static const DeviceCommandId_t RESTART_SUPERVISOR = 36;
-static const DeviceCommandId_t REQUEST_LOGGING_COUNTERS = 38;
+static const DeviceCommandId_t LOGGING_REQUEST_COUNTERS = 38;
 static constexpr DeviceCommandId_t FACTORY_RESET = 39;
 static const DeviceCommandId_t CONSECUTIVE_MRAM_DUMP = 43;
 static const DeviceCommandId_t START_MPSOC_QUIET = 45;
@ -153,13 +117,12 @@ static const DeviceCommandId_t DISABLE_AUTO_TM = 51;
 static const DeviceCommandId_t LOGGING_REQUEST_EVENT_BUFFERS = 54;
 static const DeviceCommandId_t LOGGING_CLEAR_COUNTERS = 55;
 static const DeviceCommandId_t LOGGING_SET_TOPIC = 56;
-static constexpr DeviceCommandId_t REQUEST_ADC_REPORT = 57;
+static const DeviceCommandId_t REQUEST_ADC_REPORT = 57;
 static const DeviceCommandId_t RESET_PL = 58;
 static const DeviceCommandId_t ENABLE_NVMS = 59;
 static const DeviceCommandId_t CONTINUE_UPDATE = 60;
 static const DeviceCommandId_t MEMORY_CHECK_WITH_FILE = 61;
 static constexpr DeviceCommandId_t MEMORY_CHECK = 62;
 static constexpr DeviceCommandId_t ABORT_LONGER_REQUEST = 63;
 /** Reply IDs */
 enum ReplyId : DeviceCommandId_t {
@ -168,7 +131,7 @@ enum ReplyId : DeviceCommandId_t {
  HK_REPORT = 102,
  BOOT_STATUS_REPORT = 103,
  LATCHUP_REPORT = 104,
-  COUNTERS_REPORT = 105,
+  LOGGING_REPORT = 105,
  ADC_REPORT = 106,
  UPDATE_STATUS_REPORT = 107,
 };
@ -178,7 +141,7 @@ static const uint16_t SIZE_ACK_REPORT = 14;
 static const uint16_t SIZE_EXE_REPORT = 14;
 static const uint16_t SIZE_BOOT_STATUS_REPORT = 24;
 static const uint16_t SIZE_LATCHUP_STATUS_REPORT = 31;
-static const uint16_t SIZE_COUNTERS_REPORT = 120;
+static const uint16_t SIZE_LOGGING_REPORT = 73;
 static const uint16_t SIZE_ADC_REPORT = 72;
 // 2 bits APID SRC, 00 for OBC, 2 bits APID DEST, 01 for SUPV, 7 bits CMD ID -> Mask 0x080
@ -241,18 +204,12 @@ enum class AdcMonId : uint8_t {
  SET_ENABLED_CHANNELS = 0x02,
  SET_WINDOW_STRIDE = 0x03,
  SET_ADC_THRESHOLD = 0x04,
-  COPY_ADC_DATA_TO_MRAM = 0x05,
+  COPY_ADC_DATA_TO_MRAM = 0x05
  REQUEST_ADC_SAMPLE = 0x06
 };
 enum class MemManId : uint8_t { ERASE = 0x01, WRITE = 0x02, CHECK = 0x03 };
 enum class DataLoggerServiceId : uint8_t {
  // Not implemented.
  READ_MRAM_CFG_DATA_LOGGER = 0x00,
  REQUEST_COUNTERS = 0x01,
  // Not implemented.
  EVENT_BUFFER_DOWNLOAD = 0x02,
  WIPE_MRAM = 0x05,
  DUMP_MRAM = 0x06,
  FACTORY_RESET = 0x07
@ -271,12 +228,10 @@ enum class TmtcId : uint8_t { ACK = 0x01, NAK = 0x02, EXEC_ACK = 0x03, EXEC_NAK
 enum class HkId : uint8_t { REPORT = 0x01, HARDFAULTS = 0x02 };
 enum class BootManId : uint8_t { BOOT_STATUS_REPORT = 0x01 };
 enum class AdcMonId : uint8_t { ADC_REPORT = 0x01 };
 enum class MemManId : uint8_t { UPDATE_STATUS_REPORT = 0x01 };
 enum class LatchupMonId : uint8_t { LATCHUP_STATUS_REPORT = 0x01 };
 enum class DataLoggerId : uint8_t { COUNTERS_REPORT = 0x01 };
 }  // namespace tm
@ -363,13 +318,13 @@ static const uint16_t SEQUENCE_COUNT_MASK = 0xFFF;
 static const uint8_t HK_SET_ENTRIES = 13;
 static const uint8_t BOOT_REPORT_SET_ENTRIES = 10;
 static const uint8_t LATCHUP_RPT_SET_ENTRIES = 16;
-static const uint8_t LOGGING_RPT_SET_ENTRIES = 30;
+static const uint8_t LOGGING_RPT_SET_ENTRIES = 16;
 static const uint8_t ADC_RPT_SET_ENTRIES = 32;
 static const uint32_t HK_SET_ID = HK_REPORT;
 static const uint32_t BOOT_REPORT_SET_ID = BOOT_STATUS_REPORT;
 static const uint32_t LATCHUP_RPT_ID = LATCHUP_REPORT;
-static const uint32_t LOGGING_RPT_ID = COUNTERS_REPORT;
+static const uint32_t LOGGING_RPT_ID = LOGGING_REPORT;
 static const uint32_t ADC_REPORT_SET_ID = ADC_REPORT;
 namespace timeout {
@ -434,7 +389,7 @@ enum PoolIds : lp_id_t {
  BR_SOC_STATE,
  POWER_CYCLES,
  BOOT_AFTER_MS,
-  BOOT_TIMEOUT_POOL_VAR_MS,
+  BOOT_TIMEOUT_MS,
  ACTIVE_NVM,
  BP0_STATE,
  BP1_STATE,
@ -459,8 +414,13 @@ enum PoolIds : lp_id_t {
  LATCHUP_RPT_TIME_MSEC,
  LATCHUP_RPT_IS_SET,
-  SIGNATURE,
+  LATCHUP_HAPPENED_CNT_0,
-  LATCHUP_HAPPENED_CNTS,
+  LATCHUP_HAPPENED_CNT_1,
  LATCHUP_HAPPENED_CNT_2,
  LATCHUP_HAPPENED_CNT_3,
  LATCHUP_HAPPENED_CNT_4,
  LATCHUP_HAPPENED_CNT_5,
  LATCHUP_HAPPENED_CNT_6,
  ADC_DEVIATION_TRIGGERS_CNT,
  TC_RECEIVED_CNT,
  TM_AVAILABLE_CNT,
@ -469,22 +429,40 @@ enum PoolIds : lp_id_t {
  MPSOC_BOOT_FAILED_ATTEMPTS,
  MPSOC_POWER_UP,
  MPSOC_UPDATES,
-  MPSOC_HEARTBEAT_RESETS,
+  LAST_RECVD_TC,
  CPU_WDT_RESETS,
  PS_HEARTBEATS_LOST,
  PL_HEARTBEATS_LOST,
  EB_TASK_LOST,
  BM_TASK_LOST,
  LM_TASK_LOST,
  AM_TASK_LOST,
  TCTMM_TASK_LOST,
  MM_TASK_LOST,
  HK_TASK_LOST,
  DL_TASK_LOST,
  RWS_TASKS_LOST,
-  ADC_RAW,
+  ADC_RAW_0,
-  ADC_ENG,
+  ADC_RAW_1,
  ADC_RAW_2,
  ADC_RAW_3,
  ADC_RAW_4,
  ADC_RAW_5,
  ADC_RAW_6,
  ADC_RAW_7,
  ADC_RAW_8,
  ADC_RAW_9,
  ADC_RAW_10,
  ADC_RAW_11,
  ADC_RAW_12,
  ADC_RAW_13,
  ADC_RAW_14,
  ADC_RAW_15,
  ADC_ENG_0,
  ADC_ENG_1,
  ADC_ENG_2,
  ADC_ENG_3,
  ADC_ENG_4,
  ADC_ENG_5,
  ADC_ENG_6,
  ADC_ENG_7,
  ADC_ENG_8,
  ADC_ENG_9,
  ADC_ENG_10,
  ADC_ENG_11,
  ADC_ENG_12,
  ADC_ENG_13,
  ADC_ENG_14,
  ADC_ENG_15
 };
 struct TcParams : public ploc::SpTcParams {
@ -558,6 +536,15 @@ class TmBase : public ploc::SpTmReader {
    }
  }
  bool verifyCrc() {
    if (checkCrc() == returnvalue::OK) {
      crcOk = true;
    }
    return crcOk;
  }
  bool crcIsOk() const { return crcOk; }
  uint8_t getServiceId() const { return getPacketData()[TIMESTAMP_LEN]; }
  uint16_t getModuleApid() const { return getApid() & APID_MODULE_MASK; }
@ -569,6 +556,9 @@ class TmBase : public ploc::SpTmReader {
    }
    return 0;
  }
 private:
  bool crcOk = false;
 };
 class NoPayloadPacket : public TcBase {
@ -776,6 +766,8 @@ class SetRestartTries : public TcBase {
  }
 private:
  uint8_t restartTries = 0;
  void initPacket(uint8_t restartTries) { payloadStart[0] = restartTries; }
 };
@ -836,6 +828,8 @@ class LatchupAlert : public TcBase {
  }
 private:
  uint8_t latchupId = 0;
  void initPacket(uint8_t latchupId) { payloadStart[0] = latchupId; }
 };
@ -865,6 +859,9 @@ class SetAlertlimit : public TcBase {
  }
 private:
  uint8_t latchupId = 0;
  uint32_t dutycycle = 0;
  ReturnValue_t initPacket(uint8_t latchupId, uint32_t dutycycle) {
    payloadStart[0] = latchupId;
    size_t serLen = 0;
@ -1146,14 +1143,14 @@ class WriteMemory : public TcBase {
      : TcBase(params, Apid::MEM_MAN, static_cast<uint8_t>(tc::MemManId::WRITE), 1) {}
  ReturnValue_t buildPacket(ccsds::SequenceFlags seqFlags, uint16_t sequenceCount, uint8_t memoryId,
-                            uint32_t currentAddr, uint16_t length, uint8_t* updateData) {
+                            uint32_t startAddress, uint16_t length, uint8_t* updateData) {
    if (length > CHUNK_MAX) {
      sif::error << "WriteMemory::WriteMemory: Invalid length" << std::endl;
      return SerializeIF::BUFFER_TOO_SHORT;
    }
    spParams.creator.setSeqFlags(seqFlags);
    spParams.creator.setSeqCount(sequenceCount);
-    auto res = initPacket(memoryId, currentAddr, length, updateData);
+    auto res = initPacket(memoryId, startAddress, length, updateData);
    if (res != returnvalue::OK) {
      return res;
    }
@ -1171,7 +1168,7 @@ class WriteMemory : public TcBase {
  static const uint16_t META_DATA_LENGTH = 8;
  uint8_t n = 1;
-  ReturnValue_t initPacket(uint8_t memoryId, uint32_t currentAddr, uint16_t updateDataLen,
+  ReturnValue_t initPacket(uint8_t memoryId, uint32_t startAddr, uint16_t updateDataLen,
                           uint8_t* updateData) {
    uint8_t* data = payloadStart;
    if (updateDataLen % 2 != 0) {
@ -1189,7 +1186,7 @@ class WriteMemory : public TcBase {
                                SerializeIF::Endianness::BIG);
    SerializeAdapter::serialize(&n, &data, &serializedSize, spParams.maxSize,
                                SerializeIF::Endianness::BIG);
-    SerializeAdapter::serialize(&currentAddr, &data, &serializedSize, spParams.maxSize,
+    SerializeAdapter::serialize(&startAddr, &data, &serializedSize, spParams.maxSize,
                                SerializeIF::Endianness::BIG);
    SerializeAdapter::serialize(&updateDataLen, &data, &serializedSize, spParams.maxSize,
                                SerializeIF::Endianness::BIG);
@ -1295,8 +1292,8 @@ class VerificationReport {
  virtual ~VerificationReport() = default;
-  virtual ReturnValue_t parse(bool checkCrc) {
+  virtual ReturnValue_t parse() {
-    if (checkCrc and readerBase.checkCrc() != returnvalue::OK) {
+    if (not readerBase.crcIsOk()) {
      return result::CRC_FAILURE;
    }
    if (readerBase.getModuleApid() != Apid::TMTC_MAN) {
@ -1313,27 +1310,27 @@ class VerificationReport {
    ReturnValue_t result = SerializeAdapter::deSerialize(&refApid, &payloadStart, &remLen,
                                                         SerializeIF::Endianness::BIG);
    if (result != returnvalue::OK) {
-      sif::warning << "VerificationReport: Failed to deserialize reference APID field" << std::endl;
+      sif::debug << "VerificationReport: Failed to deserialize reference APID field" << std::endl;
      return result;
    }
    result = SerializeAdapter::deSerialize(&refServiceId, &payloadStart, &remLen,
                                           SerializeIF::Endianness::BIG);
    if (result != returnvalue::OK) {
-      sif::warning << "VerificationReport: Failed to deserialize reference Service ID field"
+      sif::debug << "VerificationReport: Failed to deserialize reference Service ID field"
-                   << std::endl;
+                 << std::endl;
      return result;
    }
    result = SerializeAdapter::deSerialize(&refSeqCount, &payloadStart, &remLen,
                                           SerializeIF::Endianness::BIG);
    if (result != returnvalue::OK) {
-      sif::warning << "VerificationReport: Failed to deserialize reference sequence count field"
+      sif::debug << "VerificationReport: Failed to deserialize reference sequence count field"
-                   << std::endl;
+                 << std::endl;
      return result;
    }
    result = SerializeAdapter::deSerialize(&statusCode, &payloadStart, &remLen,
                                           SerializeIF::Endianness::BIG);
    if (result != returnvalue::OK) {
-      sif::warning << "VerificationReport: Failed to deserialize status code field" << std::endl;
+      sif::debug << "VerificationReport: Failed to deserialize status code field" << std::endl;
      return result;
    }
    return returnvalue::OK;
@ -1350,7 +1347,7 @@ class VerificationReport {
  uint32_t getStatusCode() const { return statusCode; }
-  virtual void printStatusInformation(const char* prefix) const {
+  virtual void printStatusInformation(const char* prefix) {
    bool codeHandled = true;
    if (statusCode < 0x100) {
      GeneralStatusCode code = static_cast<GeneralStatusCode>(getStatusCode());
@ -1637,15 +1634,15 @@ class AcknowledgmentReport : public VerificationReport {
 public:
  AcknowledgmentReport(TmBase& readerBase) : VerificationReport(readerBase) {}
-  ReturnValue_t parse(bool checkCrc) override {
+  virtual ReturnValue_t parse() override {
    if (readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::ACK) and
        readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::NAK)) {
      return result::INVALID_SERVICE_ID;
    }
-    return VerificationReport::parse(checkCrc);
+    return VerificationReport::parse();
  }
-  void printStatusInformationAck() {
+  void printStatusInformation() {
    VerificationReport::printStatusInformation(STATUS_PRINTOUT_PREFIX);
  }
@ -1659,15 +1656,15 @@ class ExecutionReport : public VerificationReport {
  TmBase& getReader() { return readerBase; }
-  ReturnValue_t parse(bool checkCrc) override {
+  ReturnValue_t parse() override {
    if (readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::EXEC_ACK) and
        readerBase.getServiceId() != static_cast<uint8_t>(tm::TmtcId::EXEC_NAK)) {
      return returnvalue::FAILED;
    }
-    return VerificationReport::parse(checkCrc);
+    return VerificationReport::parse();
  }
-  void printStatusInformationExe() {
+  void printStatusInformation() {
    VerificationReport::printStatusInformation(STATUS_PRINTOUT_PREFIX);
  }
@ -1679,8 +1676,8 @@ class UpdateStatusReport {
 public:
  UpdateStatusReport(TmBase& tmReader) : tmReader(tmReader) {}
-  ReturnValue_t parse(bool checkCrc) {
+  ReturnValue_t parse() {
-    if (checkCrc and tmReader.checkCrc() != returnvalue::OK) {
+    if (not tmReader.crcIsOk()) {
      return result::CRC_FAILURE;
    }
    if (tmReader.getModuleApid() != Apid::MEM_MAN) {
@ -1742,7 +1739,7 @@ class BootStatusReport : public StaticLocalDataSet<BOOT_REPORT_SET_ENTRIES> {
  lp_var_t<uint32_t> bootAfterMs = lp_var_t<uint32_t>(sid.objectId, PoolIds::BOOT_AFTER_MS, this);
  /** The currently set boot timeout */
  lp_var_t<uint32_t> bootTimeoutMs =
-      lp_var_t<uint32_t>(sid.objectId, PoolIds::BOOT_TIMEOUT_POOL_VAR_MS, this);
+      lp_var_t<uint32_t>(sid.objectId, PoolIds::BOOT_TIMEOUT_MS, this);
  lp_var_t<uint8_t> activeNvm = lp_var_t<uint8_t>(sid.objectId, PoolIds::ACTIVE_NVM, this);
  /** States of the boot partition pins */
  lp_var_t<uint8_t> bp0State = lp_var_t<uint8_t>(sid.objectId, PoolIds::BP0_STATE, this);
@ -1806,7 +1803,7 @@ class LatchupStatusReport : public StaticLocalDataSet<LATCHUP_RPT_SET_ENTRIES> {
  lp_var_t<uint8_t> timeMon = lp_var_t<uint8_t>(sid.objectId, PoolIds::LATCHUP_RPT_TIME_MON, this);
  lp_var_t<uint8_t> timeYear =
      lp_var_t<uint8_t>(sid.objectId, PoolIds::LATCHUP_RPT_TIME_YEAR, this);
-  lp_var_t<uint8_t> isSynced = lp_var_t<uint8_t>(sid.objectId, PoolIds::LATCHUP_RPT_IS_SET, this);
+  lp_var_t<uint8_t> isSet = lp_var_t<uint8_t>(sid.objectId, PoolIds::LATCHUP_RPT_IS_SET, this);
  static const uint8_t IS_SET_BIT_POS = 15;
 };
@ -1814,16 +1811,26 @@ class LatchupStatusReport : public StaticLocalDataSet<LATCHUP_RPT_SET_ENTRIES> {
 /**
 * @brief   This dataset stores the logging report.
 */
-class CountersReport : public StaticLocalDataSet<LOGGING_RPT_SET_ENTRIES> {
+class LoggingReport : public StaticLocalDataSet<LOGGING_RPT_SET_ENTRIES> {
 public:
-  CountersReport(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, LOGGING_RPT_ID) {}
+  LoggingReport(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, LOGGING_RPT_ID) {}
-  CountersReport(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, LOGGING_RPT_ID)) {}
+  LoggingReport(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, LOGGING_RPT_ID)) {}
-  lp_var_t<uint32_t> signature =
+  lp_var_t<uint32_t> latchupHappenCnt0 =
-      lp_var_t<uint32_t>(sid.objectId, PoolIds::LATCHUP_HAPPENED_CNTS, this);
+      lp_var_t<uint32_t>(sid.objectId, PoolIds::LATCHUP_HAPPENED_CNT_0, this);
-  lp_vec_t<uint32_t, 7> latchupHappenCnts =
+  lp_var_t<uint32_t> latchupHappenCnt1 =
-      lp_vec_t<uint32_t, 7>(sid.objectId, PoolIds::LATCHUP_HAPPENED_CNTS, this);
+      lp_var_t<uint32_t>(sid.objectId, PoolIds::LATCHUP_HAPPENED_CNT_1, this);
  lp_var_t<uint32_t> latchupHappenCnt2 =
      lp_var_t<uint32_t>(sid.objectId, PoolIds::LATCHUP_HAPPENED_CNT_2, this);
  lp_var_t<uint32_t> latchupHappenCnt3 =
      lp_var_t<uint32_t>(sid.objectId, PoolIds::LATCHUP_HAPPENED_CNT_3, this);
  lp_var_t<uint32_t> latchupHappenCnt4 =
      lp_var_t<uint32_t>(sid.objectId, PoolIds::LATCHUP_HAPPENED_CNT_4, this);
  lp_var_t<uint32_t> latchupHappenCnt5 =
      lp_var_t<uint32_t>(sid.objectId, PoolIds::LATCHUP_HAPPENED_CNT_5, this);
  lp_var_t<uint32_t> latchupHappenCnt6 =
      lp_var_t<uint32_t>(sid.objectId, PoolIds::LATCHUP_HAPPENED_CNT_6, this);
  lp_var_t<uint32_t> adcDeviationTriggersCnt =
      lp_var_t<uint32_t>(sid.objectId, PoolIds::ADC_DEVIATION_TRIGGERS_CNT, this);
  lp_var_t<uint32_t> tcReceivedCnt =
@ -1837,31 +1844,23 @@ class CountersReport : public StaticLocalDataSet<LOGGING_RPT_SET_ENTRIES> {
      lp_var_t<uint32_t>(sid.objectId, PoolIds::MPSOC_BOOT_FAILED_ATTEMPTS, this);
  lp_var_t<uint32_t> mpsocPowerup = lp_var_t<uint32_t>(sid.objectId, PoolIds::MPSOC_POWER_UP, this);
  lp_var_t<uint32_t> mpsocUpdates = lp_var_t<uint32_t>(sid.objectId, PoolIds::MPSOC_UPDATES, this);
-  lp_var_t<uint32_t> mpsocHeartbeatResets =
+  lp_var_t<uint32_t> lastRecvdTc = lp_var_t<uint32_t>(sid.objectId, PoolIds::LAST_RECVD_TC, this);
      lp_var_t<uint32_t>(sid.objectId, PoolIds::MPSOC_HEARTBEAT_RESETS, this);
  lp_var_t<uint32_t> cpuWdtResets =
      lp_var_t<uint32_t>(sid.objectId, PoolIds::MPSOC_HEARTBEAT_RESETS, this);
  lp_var_t<uint32_t> psHeartbeatsLost =
      lp_var_t<uint32_t>(sid.objectId, PoolIds::PS_HEARTBEATS_LOST, this);
  lp_var_t<uint32_t> plHeartbeatsLost =
      lp_var_t<uint32_t>(sid.objectId, PoolIds::PL_HEARTBEATS_LOST, this);
  lp_var_t<uint32_t> ebTaskLost = lp_var_t<uint32_t>(sid.objectId, PoolIds::EB_TASK_LOST, this);
  lp_var_t<uint32_t> bmTaskLost = lp_var_t<uint32_t>(sid.objectId, PoolIds::BM_TASK_LOST, this);
  lp_var_t<uint32_t> lmTaskLost = lp_var_t<uint32_t>(sid.objectId, PoolIds::LM_TASK_LOST, this);
  lp_var_t<uint32_t> amTaskLost = lp_var_t<uint32_t>(sid.objectId, PoolIds::AM_TASK_LOST, this);
  lp_var_t<uint32_t> tctmmTaskLost =
      lp_var_t<uint32_t>(sid.objectId, PoolIds::TCTMM_TASK_LOST, this);
  lp_var_t<uint32_t> mmTaskLost = lp_var_t<uint32_t>(sid.objectId, PoolIds::MM_TASK_LOST, this);
  lp_var_t<uint32_t> hkTaskLost = lp_var_t<uint32_t>(sid.objectId, PoolIds::HK_TASK_LOST, this);
  lp_var_t<uint32_t> dlTaskLost = lp_var_t<uint32_t>(sid.objectId, PoolIds::DL_TASK_LOST, this);
  lp_vec_t<uint32_t, 3> rwsTasksLost =
      lp_vec_t<uint32_t, 3>(sid.objectId, PoolIds::RWS_TASKS_LOST, this);
  void printSet() {
-    for (unsigned i = 0; i < 7; i++) {
+    sif::info << "LoggingReport: Latchup happened count 0: " << this->latchupHappenCnt0
-      sif::info << "LoggingReport: Latchup happened count " << i << ": "
+              << std::endl;
-                << this->latchupHappenCnts[i] << std::endl;
+    sif::info << "LoggingReport: Latchup happened count 1: " << this->latchupHappenCnt1
-    }
+              << std::endl;
    sif::info << "LoggingReport: Latchup happened count 2: " << this->latchupHappenCnt2
              << std::endl;
    sif::info << "LoggingReport: Latchup happened count 3: " << this->latchupHappenCnt3
              << std::endl;
    sif::info << "LoggingReport: Latchup happened count 4: " << this->latchupHappenCnt4
              << std::endl;
    sif::info << "LoggingReport: Latchup happened count 5: " << this->latchupHappenCnt5
              << std::endl;
    sif::info << "LoggingReport: Latchup happened count 6: " << this->latchupHappenCnt6
              << std::endl;
    sif::info << "LoggingReport: ADC deviation triggers count: " << this->adcDeviationTriggersCnt
              << std::endl;
    sif::info << "LoggingReport: TC received count: " << this->tcReceivedCnt << std::endl;
@ -1872,29 +1871,88 @@ class CountersReport : public StaticLocalDataSet<LOGGING_RPT_SET_ENTRIES> {
              << std::endl;
    sif::info << "LoggingReport: MPSoC power up: " << this->mpsocPowerup << std::endl;
    sif::info << "LoggingReport: MPSoC updates: " << this->mpsocUpdates << std::endl;
    sif::info << "LoggingReport: APID of last received TC: 0x" << std::hex << this->lastRecvdTc
              << std::endl;
  }
 };
 /**
 * @brief   This dataset stores the ADC report.
 */
-class AdcReport : public StaticLocalDataSet<3> {
+class AdcReport : public StaticLocalDataSet<ADC_RPT_SET_ENTRIES> {
 public:
  AdcReport(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, ADC_REPORT_SET_ID) {}
  AdcReport(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, ADC_REPORT_SET_ID)) {}
-  lp_vec_t<uint16_t, 16> adcRaw = lp_vec_t<uint16_t, 16>(sid.objectId, PoolIds::ADC_RAW, this);
+  lp_var_t<uint16_t> adcRaw0 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_0, this);
-  lp_vec_t<uint16_t, 16> adcEng = lp_vec_t<uint16_t, 16>(sid.objectId, PoolIds::ADC_ENG, this);
+  lp_var_t<uint16_t> adcRaw1 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_1, this);
  lp_var_t<uint16_t> adcRaw2 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_2, this);
  lp_var_t<uint16_t> adcRaw3 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_3, this);
  lp_var_t<uint16_t> adcRaw4 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_4, this);
  lp_var_t<uint16_t> adcRaw5 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_5, this);
  lp_var_t<uint16_t> adcRaw6 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_6, this);
  lp_var_t<uint16_t> adcRaw7 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_7, this);
  lp_var_t<uint16_t> adcRaw8 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_8, this);
  lp_var_t<uint16_t> adcRaw9 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_9, this);
  lp_var_t<uint16_t> adcRaw10 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_10, this);
  lp_var_t<uint16_t> adcRaw11 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_11, this);
  lp_var_t<uint16_t> adcRaw12 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_12, this);
  lp_var_t<uint16_t> adcRaw13 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_13, this);
  lp_var_t<uint16_t> adcRaw14 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_14, this);
  lp_var_t<uint16_t> adcRaw15 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_RAW_15, this);
  lp_var_t<uint16_t> adcEng0 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_0, this);
  lp_var_t<uint16_t> adcEng1 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_1, this);
  lp_var_t<uint16_t> adcEng2 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_2, this);
  lp_var_t<uint16_t> adcEng3 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_3, this);
  lp_var_t<uint16_t> adcEng4 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_4, this);
  lp_var_t<uint16_t> adcEng5 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_5, this);
  lp_var_t<uint16_t> adcEng6 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_6, this);
  lp_var_t<uint16_t> adcEng7 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_7, this);
  lp_var_t<uint16_t> adcEng8 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_8, this);
  lp_var_t<uint16_t> adcEng9 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_9, this);
  lp_var_t<uint16_t> adcEng10 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_10, this);
  lp_var_t<uint16_t> adcEng11 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_11, this);
  lp_var_t<uint16_t> adcEng12 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_12, this);
  lp_var_t<uint16_t> adcEng13 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_13, this);
  lp_var_t<uint16_t> adcEng14 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_14, this);
  lp_var_t<uint16_t> adcEng15 = lp_var_t<uint16_t>(sid.objectId, PoolIds::ADC_ENG_15, this);
  void printSet() {
    sif::info << "---- Adc Report: Raw values ----" << std::endl;
-    for (unsigned i = 0; i < 16; i++) {
+    sif::info << "AdcReport: ADC raw 0: " << std::dec << this->adcRaw0 << std::endl;
-      sif::info << "AdcReport: ADC raw " << i << ": " << std::dec << this->adcRaw[i] << std::endl;
+    sif::info << "AdcReport: ADC raw 1: " << this->adcRaw1 << std::endl;
-    }
+    sif::info << "AdcReport: ADC raw 2: " << this->adcRaw2 << std::endl;
-    for (unsigned i = 0; i < 16; i++) {
+    sif::info << "AdcReport: ADC raw 3: " << this->adcRaw3 << std::endl;
-      sif::info << "AdcReport: ADC eng " << i << ": " << std::dec << this->adcEng[i] << std::endl;
+    sif::info << "AdcReport: ADC raw 4: " << this->adcRaw4 << std::endl;
-    }
+    sif::info << "AdcReport: ADC raw 5: " << this->adcRaw5 << std::endl;
    sif::info << "AdcReport: ADC raw 6: " << this->adcRaw6 << std::endl;
    sif::info << "AdcReport: ADC raw 7: " << this->adcRaw7 << std::endl;
    sif::info << "AdcReport: ADC raw 8: " << this->adcRaw8 << std::endl;
    sif::info << "AdcReport: ADC raw 9: " << this->adcRaw9 << std::endl;
    sif::info << "AdcReport: ADC raw 10: " << this->adcRaw10 << std::endl;
    sif::info << "AdcReport: ADC raw 11: " << this->adcRaw11 << std::endl;
    sif::info << "AdcReport: ADC raw 12: " << this->adcRaw12 << std::endl;
    sif::info << "AdcReport: ADC raw 13: " << this->adcRaw13 << std::endl;
    sif::info << "AdcReport: ADC raw 14: " << this->adcRaw14 << std::endl;
    sif::info << "AdcReport: ADC raw 15: " << this->adcRaw15 << std::endl;
    sif::info << "---- Adc Report: Engineering values ----" << std::endl;
    sif::info << "AdcReport: ADC eng 0: " << this->adcEng0 << std::endl;
    sif::info << "AdcReport: ADC eng 1: " << this->adcEng1 << std::endl;
    sif::info << "AdcReport: ADC eng 2: " << this->adcEng2 << std::endl;
    sif::info << "AdcReport: ADC eng 3: " << this->adcEng3 << std::endl;
    sif::info << "AdcReport: ADC eng 4: " << this->adcEng4 << std::endl;
    sif::info << "AdcReport: ADC eng 5: " << this->adcEng5 << std::endl;
    sif::info << "AdcReport: ADC eng 6: " << this->adcEng6 << std::endl;
    sif::info << "AdcReport: ADC eng 7: " << this->adcEng7 << std::endl;
    sif::info << "AdcReport: ADC eng 8: " << this->adcEng8 << std::endl;
    sif::info << "AdcReport: ADC eng 9: " << this->adcEng9 << std::endl;
    sif::info << "AdcReport: ADC eng 10: " << this->adcEng10 << std::endl;
    sif::info << "AdcReport: ADC eng 11: " << this->adcEng11 << std::endl;
    sif::info << "AdcReport: ADC eng 12: " << this->adcEng12 << std::endl;
    sif::info << "AdcReport: ADC eng 13: " << this->adcEng13 << std::endl;
    sif::info << "AdcReport: ADC eng 14: " << this->adcEng14 << std::endl;
    sif::info << "AdcReport: ADC eng 15: " << this->adcEng15 << std::endl;
  }
 };
@ -1984,7 +2042,11 @@ class EnableNvms : public TcBase {
 */
 class EnableAutoTm : public TcBase {
 public:
-  EnableAutoTm(TcParams params) : TcBase(params) { spParams.setFullPayloadLen(PAYLOAD_LENGTH + 2); }
+  EnableAutoTm(TcParams params) : TcBase(params) {
    spParams.setFullPayloadLen(PAYLOAD_LENGTH + 2);
    // spParams.creator.setApid(APID_AUTO_TM);
    // spParams.creator.setSeqCount(DEFAULT_SEQUENCE_COUNT);
  }
  ReturnValue_t buildPacket() {
    auto res = checkSizeAndSerializeHeader();
--- a/linux/scheduling.cpp
+++ b/linux/scheduling.cpp
@ -47,3 +47,35 @@ void scheduling::addMpsocSupvHandlers(PeriodicTaskIF* plTask) {
  plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::SEND_READ);
  plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::GET_READ);
 }
 void scheduling::scheduleScexDev(PeriodicTaskIF*& scexDevHandler) {
  ReturnValue_t result =
      scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::PERFORM_OPERATION);
  if (result != returnvalue::OK) {
    printAddObjectError("SCEX_DEV", objects::SCEX);
  }
  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_WRITE);
  if (result != returnvalue::OK) {
    printAddObjectError("SCEX_DEV", objects::SCEX);
  }
  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_WRITE);
  if (result != returnvalue::OK) {
    printAddObjectError("SCEX_DEV", objects::SCEX);
  }
  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_READ);
  if (result != returnvalue::OK) {
    printAddObjectError("SCEX_DEV", objects::SCEX);
  }
  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_READ);
  if (result != returnvalue::OK) {
    printAddObjectError("SCEX_DEV", objects::SCEX);
  }
  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_READ);
  if (result != returnvalue::OK) {
    printAddObjectError("SCEX_DEV", objects::SCEX);
  }
  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_READ);
  if (result != returnvalue::OK) {
    printAddObjectError("SCEX_DEV", objects::SCEX);
  }
 }
--- a/linux/scheduling.h
+++ b/linux/scheduling.h
@ -8,6 +8,7 @@ namespace scheduling {
 extern PosixThreadArgs RR_SCHEDULING;
 extern PosixThreadArgs NORMAL_SCHEDULING;
 void scheduleScexDev(PeriodicTaskIF*& scexDevHandler);
 void scheduleScexReader(TaskFactory& factory, PeriodicTaskIF*& scexReaderTask);
 void addMpsocSupvHandlers(PeriodicTaskIF* task);
 }  // namespace scheduling
--- a/mission/acs/ImtqHandler.cpp
+++ b/mission/acs/ImtqHandler.cpp
@ -795,9 +795,9 @@ ReturnValue_t ImtqHandler::initializeLocalDataPool(localpool::DataPool& localDat
  localDataPoolMap.emplace(imtq::FINA_NEG_Z_COIL_Z_TEMPERATURE, new PoolEntry<int16_t>({0}));
  poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(hkDatasetNoTorque.getSid(), enableHkSets, 60.0));
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetNoTorque.getSid(), enableHkSets, 30.0));
  poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(hkDatasetWithTorque.getSid(), enableHkSets, 60.0));
+      subdp::DiagnosticsHkPeriodicParams(hkDatasetWithTorque.getSid(), enableHkSets, 30.0));
  poolManager.subscribeForDiagPeriodicPacket(
      subdp::DiagnosticsHkPeriodicParams(rawMtmNoTorque.getSid(), false, 10.0));
  poolManager.subscribeForDiagPeriodicPacket(
--- a/mission/acs/RwHandler.cpp
+++ b/mission/acs/RwHandler.cpp
@ -340,7 +340,7 @@ ReturnValue_t RwHandler::initializeLocalDataPool(localpool::DataPool& localDataP
  localDataPoolMap.emplace(rws::SPI_REG_OVERRUN_ERRORS, new PoolEntry<uint32_t>({0}));
  localDataPoolMap.emplace(rws::SPI_TOTAL_ERRORS, new PoolEntry<uint32_t>({0}));
  poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(statusSet.getSid(), false, 30.0));
+      subdp::DiagnosticsHkPeriodicParams(statusSet.getSid(), false, 12.0));
  poolManager.subscribeForRegularPeriodicPacket(
      subdp::RegularHkPeriodicParams(tmDataset.getSid(), false, 30.0));
  poolManager.subscribeForRegularPeriodicPacket(
--- a/Show More
+++ b/Show More
		`@ -1 +0,0 @@`
			`# target_sources(${OBSW_NAME} PUBLIC <Source File List>)`
`@ -1,2 +1 @@`
	`target_sources(${OBSW_NAME} PRIVATE CoreController.cpp WatchdogHandler.cpp`	`target_sources(${OBSW_NAME} PRIVATE CoreController.cpp WatchdogHandler.cpp)`
	`XiphosWdtHandler.cpp)`
		`@ -1 +1 @@`
			`Subproject commit 42867ad0cba088ab1cb6cb672d001f991f7e4a60`				`Subproject commit d246ce34d05ecc5c722fd127e61556374961c899`