afmt and bump patch

sus convert bugfix
changelog
2023-06-24 14:35:44 +02:00 · 2023-06-24 14:26:46 +02:00 · 2023-06-24 14:26:13 +02:00 · 2023-06-24 14:25:23 +02:00 · 2023-06-24 14:25:16 +02:00
128 changed files with 1598 additions and 3385 deletions
--- a/.idea/cmake.xml
+++ b/.idea/cmake.xml
@ -2,7 +2,7 @@
 <project version="4">
  <component name="CMakeSharedSettings">
    <configurations>
-      <configuration PROFILE_NAME="Debug Q7S" ENABLED="true" CONFIG_NAME="Debug" TOOLCHAIN_NAME="Default" GENERATION_OPTIONS="-DTGT_BSP=&quot;arm/q7s&quot;" NO_GENERATOR="true">
+      <configuration PROFILE_NAME="Debug Q7S" ENABLED="true" CONFIG_NAME="Debug" TOOLCHAIN_NAME="Q7S" GENERATION_OPTIONS="-DTGT_BSP=&quot;arm/q7s&quot;" NO_GENERATOR="true">
        <ADDITIONAL_GENERATION_ENVIRONMENT>
          <envs>
            <env name="ZYNQ_7020_ROOTFS" value="/opt/xiphos/sdk/ark/sysroots/cortexa9hf-neon-xiphos-linux-gnueabi" />
@ -10,7 +10,6 @@
          </envs>
        </ADDITIONAL_GENERATION_ENVIRONMENT>
      </configuration>
-      <configuration PROFILE_NAME="Debug" ENABLED="true" CONFIG_NAME="Debug" NO_GENERATOR="true" />
    </configurations>
  </component>
 </project>
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -16,166 +16,7 @@ will consitute of a breaking change warranting a new major release:

 # [unreleased]

-# [v6.2.0] 2023-07-26
-
- `eive-tmtc`: v5.3.1
-
-## Changed
-
- STR missed reply handling is now moved to DHB rather than the COM interface. The COM IF will
-  still trigger an event if a reply is taking too long, and FDIR should still work via reply
-  timeouts.
- Re-ordered some functions of the core controller in the initialize function.
- Rad sensor is now only polled every 30 minutes instead of every device cycle to reduce wear of
-  the RADFET electronics.
- The SD cards will still be switched OFF on a reboot, but this is done in a non-blocking manner
-  now with a timeout of 10 seconds where the reboot will be performed in any case.
- ACS Controller now includes the safe mode from FLP, which will calculate its rotational rate
-  from SUS and MGM measurements. To accommodate these changes, low-pass filters for SUS
-  measurements and rates as well as MGM measurements and rates are included. Usage of the new
-  controller as well as settings of the low-pass filters can be handled via parameter commands.
- Simplify and fix the chip and copy protection functions in the core controller. This mechanism
-  now is always performed for the target chip and target copy in the reboot handlers.
-
-## Added
-
- 5 ms delay after pulling RADFET enable pin high before starting
-  the ADC conversion.
- Set STR time in configuration sequence to firmware mode.
- The STR `AutoThreshold` parameters are now set from the configuration JSON file at STR
-  startup.
- The STR handler can now handle the COM error reply and triggers an low severity event accordingly.
- Add SCEX handler for EM.
- Radiation sensor handler dummy for the EM.
- Added event for SD card information in core controller initialize function. This event will also
-  be triggered after the SD state machine has run, so the event will generally be triggered twice
-  at system boot, and once after commanding SD card switches.
-
-## Fixed
-
- General bugs in the SD card state machine. This might fix some other known bugs for certain
-  combinations of switching ON and OFF SD cards and also makes the whole state machine a lot more
-  robust against hanging up.
- SUS dummy handler went to `MODE_NORMAL` for ON commands.
- PL PCDU dummy went to `MODE_NORMAL` for ON commands.
-
-# [v6.1.0] 2023-07-13
-
- `eive-tmtc`: v5.2.0
-
-## Changed
-
- TCS: Remove OBC IF board thermal module, which is exactly identical to OBC module and therefore
-  obsolete.
- Swapped PL and PS I2C, BPX battery and MGT are connected to PS I2C now for firmware versions
-  equal or above v4. However, this software version is compatible to both v3 and v4 of the firmware.
- The firmware version variables are global statics inititalized early during the program
-  runtime now. This makes it possible to check the firmware version earlier.
- The TCS controller will now always command heaters OFF when being blind for thermal
-  components (no sensors available), irrespective of current switch state.
- Make OBSW compatible to prospective FW version v5.0.0, where the Q7 I2C devices were
-  moved to a PL I2C block and the TMP sensor devices were moved to the PS I2C0.
- Made `Xadc` code a little bit more robust against errors.
-
-## Fixed
-
- TMP1075: Set dataset invalid on shutdown explicitely
- Small fixes for TMP1075 FDIR: Use strange and missed reply counters.
- TCS controller: Last heater (S-band heater) was skipped for transition completion
-  checks.
- TCS controller: A helper member to track the elapsed heater control cycles was not reset
-  properly, which could lead to switch transitions being completed immediately. This can
-  lead to weird bugs like heaters being commanded ON twice and can potentially lead to
-  other bugs.
- TMP1075: Devices did not go to OFF mode when being set faulty.
- Update PL PCDU 1 in TCS mode tree on the EM.
- TMP1075: Possibly ignored health commands.
- Bugfix in FSFW where certain packet types could only be sent with source data fields with a
-  maximum size of 255 bytes.
- TCS CTRL: Limit number of heater handler messages sent in case there are not sensors available
-  anymore.
- Fix to allow adding real STR device for EM.
-
-# Added
-
- Two events for heaters being commanded ON and OFF by the TCS controller
- Upper limit for burn time of TCS heaters. Currently set to 1 hour for each heater.
-  This mechanism will only track the burn time for heaters which were commanded by the
-  TCS controller.
- TCS controller is now observable by introducing a new HK dataset which exposes some internal
-  fields related to TCS control.
-
-# [v6.0.0] 2023-07-02
-
- `q7s-package` version v3.2.0
- Important bugfixes for PTME. See `q7s-package` CHANGELOG.
-
-## Changed
-
- Added back PTME busy bit polling. This is necessary due to changes to the AXI APB interface
-  to the PTME core.
-
-## Fixed
-
- For the live channel (VC0), telemetry was still only dumped if the transmitter is active.
-  Please note that this fix will lead to crashes for FW versions below v3.2.
-  However, it might not be an issue for the oldest firmware on the satellite (v2.5.1).
-
-# [v5.2.0] 2023-07-02
-
-## Fixed
-
- The firmware information event was not triggered even when possible because of an ordering
-  bug in the initializer function.
- Empty dumps (no TM in time range) will now correctly be completed immediately
-
-## Changed
-
- PTME was always reset on submode changes. The reset will now only be performed if the actual data
-  rate changes.
- Add back ACS board code for the EM. Now that the radiation sensor was removed, the image switching
-  issue has disappeared and adding back the ACS board is worth it for the GPS timekeeping.
-
-# [v5.1.0] 2023-06-28
-
- `eive-tmtc` version v5.1.0
-
-## Changed
-
- Persistent TM store dumps are now performed in chronological order.
- Increase Syrlinks RX HK rate to 5.0 seconds during a pass.
- Various robustness improvements for the heater handler. The heater handler will now only
-  process the command queue if it is not busy with switch commanding which reduces the amount
-  of possible bugs.
- The heater handler is only able to process messages stricly sequentially now but is scheduled
-  twice in a 0.5 second slot so something like a consecutive heater ON or OFF command can still
-  be handled relatively quickly.
-
-## Added
-
- Sequence counters for PUS and CFDP packets are now stored persistently across graceful reboots.
- The PUS packet message type counter will now be incremented properly for each PUS service.
- Internal error reporter set is now enabled by default and generated every 120 seconds.
-
-# [v5.0.0] 2023-06-26
-
-v3.3.1 and all following version will now be moved to v5.0.0 with the additional changes listed
-here. This was done because the firmware update (v4.0.0) is not working right now and it is not
-known when and how it will be fixed. Because of that, all updates to make the SW work with the new
-firmware, which are limited to a few files will be moved to a dev branch so regular development
-compatible to the old firmware can continue.
-
-TLDR: This version is compatible to the old firmware and some changes which only work with the new
-firmware have been reverted.
-
-## Changed
-
- Added `sync` syscall in graceful shutdown handler
- Graceful shutdown is now performed by the reboot watchdog
- There is now a separate file for the total reboot counter. The reboot watchdog has its own local
-  counters to determine whether a reboot is necessary.
-
-# [v4.0.1] 2023-06-24
+# [v4.0.1] 2023-06-23

 ## Fixed

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -9,9 +9,9 @@
 # ##############################################################################
 cmake_minimum_required(VERSION 3.13)

-set(OBSW_VERSION_MAJOR 6)
-set(OBSW_VERSION_MINOR 2)
-set(OBSW_VERSION_REVISION 0)
+set(OBSW_VERSION_MAJOR 3)
+set(OBSW_VERSION_MINOR 3)
+set(OBSW_VERSION_REVISION 1)

 # set(CMAKE_VERBOSE TRUE)

@ -93,7 +93,7 @@ set(OBSW_ADD_BPX_BATTERY_HANDLER
    1
    CACHE STRING "Add BPX battery module")
 set(OBSW_ADD_STAR_TRACKER
-    1
+    ${INIT_VAL}
    CACHE STRING "Add Startracker module")
 set(OBSW_ADD_SUN_SENSORS
    ${INIT_VAL}
@ -105,7 +105,7 @@ set(OBSW_ADD_THERMAL_TEMP_INSERTER
    ${OBSW_Q7S_EM}
    CACHE STRING "Add thermal sensor temperature inserter")
 set(OBSW_ADD_ACS_BOARD
-    1
+    ${INIT_VAL}
    CACHE STRING "Add ACS board module")
 set(OBSW_ADD_GPS_CTRL
    ${INIT_VAL}
@ -150,7 +150,7 @@ set(OBSW_ADD_SYRLINKS
    1
    CACHE STRING "Add Syrlinks module")
 set(OBSW_ADD_TMP_DEVICES
-    1
+    ${INIT_VAL}
    CACHE STRING "Add TMP devices")
 set(OBSW_ADD_GOMSPACE_PCDU
    1
@ -162,7 +162,7 @@ set(OBSW_ADD_RW
    ${INIT_VAL}
    CACHE STRING "Add RW modules")
 set(OBSW_ADD_SCEX_DEVICE
-    1
+    ${INIT_VAL}
    CACHE STRING "Add Solar Cell Experiment module")
 set(OBSW_SYRLINKS_SIMULATED
    0
--- a/README.md
+++ b/README.md
@ -964,12 +964,6 @@ used by other software components to read the current chip and copy.
 This is a configuration scripts which runs after the Network Time Protocol has run. This script
 currently sets the static IP address `192.168.133.10` and starts the `can` interface.

-## Initial boot delay
-
-You can create a file named `boot_delays_secs.txt` inside the home folder to delay the OBSW boot
-for 6 seconds if the file is empty of for the number of seconds specified inside the file. This
-can be helpful if something inside the OBSW leads to an immediate crash of the OBC.
-
 ## PCDU

 Connect to serial console of P60 Dock
--- a/bsp_hosted/ObjectFactory.cpp
+++ b/bsp_hosted/ObjectFactory.cpp
@ -68,7 +68,7 @@ void ObjectFactory::produce(void* args) {
 #endif
  auto sdcMan = new DummySdCardManager("/tmp");
  ObjectFactory::produceGenericObjects(nullptr, &pusFunnel, &cfdpFunnel, *sdcMan, &ipcStore,
-                                       &tmStore, persistentStores, 120, enableHkSets);
+                                       &tmStore, persistentStores, 120);

  new TmFunnelHandler(objects::LIVE_TM_TASK, *pusFunnel, *cfdpFunnel);
  auto* dummyGpioIF = new DummyGpioIF();
@ -113,7 +113,7 @@ void ObjectFactory::produce(void* args) {
  if (heaterHandler == nullptr) {
    sif::error << "HeaterHandler could not be created" << std::endl;
  } else {
-    ObjectFactory::createThermalController(*heaterHandler, true);
+    ObjectFactory::createThermalController(*heaterHandler);
  }
  new TestTask(objects::TEST_TASK);
 }
--- 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 301 translations.
+ * @brief    Auto-generated event translation file. Contains 295 translations.
 * @details
- * Generated on: 2023-07-26 12:51:20
+ * Generated on: 2023-05-17 17:15:34
 */
 #include "translateEvents.h"

@ -139,7 +139,6 @@ const char *ERROR_STATE_STRING = "ERROR_STATE";
 const char *RESET_OCCURED_STRING = "RESET_OCCURED";
 const char *BOOTING_FIRMWARE_FAILED_EVENT_STRING = "BOOTING_FIRMWARE_FAILED_EVENT";
 const char *BOOTING_BOOTLOADER_FAILED_EVENT_STRING = "BOOTING_BOOTLOADER_FAILED_EVENT";
-const char *COM_ERROR_REPLY_RECEIVED_STRING = "COM_ERROR_REPLY_RECEIVED";
 const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
 const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
 const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
@ -278,8 +277,6 @@ const char *INDIVIDUAL_BOOT_COUNTS_STRING = "INDIVIDUAL_BOOT_COUNTS";
 const char *TRYING_I2C_RECOVERY_STRING = "TRYING_I2C_RECOVERY";
 const char *I2C_REBOOT_STRING = "I2C_REBOOT";
 const char *PDEC_REBOOT_STRING = "PDEC_REBOOT";
-const char *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
-const char *ACTIVE_SD_INFO_STRING = "ACTIVE_SD_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@ -288,9 +285,6 @@ const char *CAMERA_OVERHEATING_STRING = "CAMERA_OVERHEATING";
 const char *PCDU_SYSTEM_OVERHEATING_STRING = "PCDU_SYSTEM_OVERHEATING";
 const char *HEATER_NOT_OFF_FOR_OFF_MODE_STRING = "HEATER_NOT_OFF_FOR_OFF_MODE";
 const char *MGT_OVERHEATING_STRING = "MGT_OVERHEATING";
-const char *TCS_SWITCHING_HEATER_ON_STRING = "TCS_SWITCHING_HEATER_ON";
-const char *TCS_SWITCHING_HEATER_OFF_STRING = "TCS_SWITCHING_HEATER_OFF";
-const char *TCS_HEATER_MAX_BURN_TIME_REACHED_STRING = "TCS_HEATER_MAX_BURN_TIME_REACHED";
 const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
 const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
 const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
@ -577,8 +571,6 @@ const char *translateEvents(Event event) {
      return BOOTING_FIRMWARE_FAILED_EVENT_STRING;
    case (11902):
      return BOOTING_BOOTLOADER_FAILED_EVENT_STRING;
-    case (11903):
-      return COM_ERROR_REPLY_RECEIVED_STRING;
    case (12001):
      return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
    case (12002):
@ -855,10 +847,6 @@ const char *translateEvents(Event event) {
      return I2C_REBOOT_STRING;
    case (14012):
      return PDEC_REBOOT_STRING;
-    case (14013):
-      return FIRMWARE_INFO_STRING;
-    case (14014):
-      return ACTIVE_SD_INFO_STRING;
    case (14100):
      return NO_VALID_SENSOR_TEMPERATURE_STRING;
    case (14101):
@ -875,12 +863,6 @@ const char *translateEvents(Event event) {
      return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
    case (14108):
      return MGT_OVERHEATING_STRING;
-    case (14109):
-      return TCS_SWITCHING_HEATER_ON_STRING;
-    case (14110):
-      return TCS_SWITCHING_HEATER_OFF_STRING;
-    case (14111):
-      return TCS_HEATER_MAX_BURN_TIME_REACHED_STRING;
    case (14201):
      return TX_TIMER_EXPIRED_STRING;
    case (14202):
--- a/bsp_hosted/fsfwconfig/objects/translateObjects.cpp
+++ b/bsp_hosted/fsfwconfig/objects/translateObjects.cpp
@ -2,7 +2,7 @@
 * @brief  Auto-generated object translation file.
 * @details
 * Contains 171 translations.
- * Generated on: 2023-07-26 12:51:20
+ * Generated on: 2023-05-17 17:15:34
 */
 #include "translateObjects.h"

--- a/bsp_q7s/CMakeLists.txt
+++ b/bsp_q7s/CMakeLists.txt
@ -7,8 +7,7 @@ target_link_libraries(${SIMPLE_OBSW_NAME} PUBLIC ${LIB_FSFW_NAME})
 target_compile_definitions(${SIMPLE_OBSW_NAME} PRIVATE "Q7S_SIMPLE_MODE")
 add_subdirectory(simple)

-target_sources(${OBSW_NAME} PUBLIC main.cpp obsw.cpp scheduling.cpp
-                                   objectFactory.cpp)
+target_sources(${OBSW_NAME} PUBLIC main.cpp obsw.cpp)

 add_subdirectory(boardtest)

--- a/bsp_q7s/boardconfig/busConf.h
+++ b/bsp_q7s/boardconfig/busConf.h
@ -12,9 +12,6 @@ static constexpr char SPI_RW_DEV[] = "/dev/spi_rw";
 static constexpr char I2C_PL_EIVE[] = "/dev/i2c_pl";
 //! I2C bus using the I2C peripheral of the ARM processing system (PS)
 static constexpr char I2C_PS_EIVE[] = "/dev/i2c_ps";
-//! I2C bus using the first I2C peripheral of the ARM processing system (PS).
-//! Named like this because it is used by default for the Q7 devices.
-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";
@ -26,7 +23,6 @@ static constexpr char UART_SCEX_DEV[] = "/dev/scex";
 static constexpr char UIO_PDEC_REGISTERS[] = "/dev/uio_pdec_regs";
 static constexpr char UIO_PTME[] = "/dev/uio_ptme";
 static constexpr char UIO_PDEC_CONFIG_MEMORY[] = "/dev/uio_pdec_cfg_mem";
-static constexpr char UIO_SYS_ROM[] = "/dev/uio_sys_rom";
 static constexpr char UIO_PDEC_RAM[] = "/dev/uio_pdec_ram";
 static constexpr char UIO_PDEC_IRQ[] = "/dev/uio_pdec_irq";
 static constexpr int MAP_ID_PTME_CONFIG = 3;
@ -61,7 +57,6 @@ static constexpr char GYRO_0_ENABLE[] = "enable_gyro_0";
 static constexpr char GYRO_2_ENABLE[] = "enable_gyro_2";
 static constexpr char GNSS_SELECT[] = "gnss_mux_select";
 static constexpr char GNSS_MUX_SELECT[] = "gnss_mux_select";
-static constexpr char PL_I2C_ARESETN[] = "pl_i2c_aresetn";

 static constexpr char HEATER_0[] = "heater0";
 static constexpr char HEATER_1[] = "heater1";
@ -87,12 +82,14 @@ static constexpr char EN_RW_4[] = "enable_rw_4";

 static constexpr char RAD_SENSOR_CHIP_SELECT[] = "rad_sensor_chip_select";
 static constexpr char ENABLE_RADFET[] = "enable_radfet";
-
+static constexpr char PAPB_BUSY_SIGNAL_VC0[] = "papb_busy_signal_vc0";
 static constexpr char PAPB_EMPTY_SIGNAL_VC0[] = "papb_empty_signal_vc0";
+static constexpr char PAPB_BUSY_SIGNAL_VC1[] = "papb_busy_signal_vc1";
 static constexpr char PAPB_EMPTY_SIGNAL_VC1[] = "papb_empty_signal_vc1";
+static constexpr char PAPB_BUSY_SIGNAL_VC2[] = "papb_busy_signal_vc2";
 static constexpr char PAPB_EMPTY_SIGNAL_VC2[] = "papb_empty_signal_vc2";
+static constexpr char PAPB_BUSY_SIGNAL_VC3[] = "papb_busy_signal_vc3";
 static constexpr char PAPB_EMPTY_SIGNAL_VC3[] = "papb_empty_signal_vc3";
-
 static constexpr char PTME_RESETN[] = "ptme_resetn";

 static constexpr char RS485_EN_TX_CLOCK[] = "tx_clock_enable_ltc2872";
--- a/bsp_q7s/boardtest/Q7STestTask.cpp
+++ b/bsp_q7s/boardtest/Q7STestTask.cpp
@ -218,30 +218,15 @@ void Q7STestTask::testProtHandler() {
  bool opPerformed = false;
  ReturnValue_t result = returnvalue::OK;
  // If any chips are unlocked, lock them here
-  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::CHIP_0, xsc::Copy::COPY_0,
-                                                              true);
-  if (result != returnvalue::OK) {
-    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
-  }
-  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::CHIP_0, xsc::Copy::COPY_1,
-                                                              true);
-  if (result != returnvalue::OK) {
-    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
-  }
-  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::CHIP_1, xsc::Copy::COPY_0,
-                                                              true);
-  if (result != returnvalue::OK) {
-    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
-  }
-  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::CHIP_1, xsc::Copy::COPY_1,
-                                                              true);
+  result = coreController->setBootCopyProtection(xsc::Chip::ALL_CHIP, xsc::Copy::ALL_COPY, true,
+                                                 opPerformed, true);
  if (result != returnvalue::OK) {
    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
  }

  // unlock own copy
-  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::SELF_CHIP,
-                                                              xsc::Copy::SELF_COPY, false);
+  result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, false,
+                                                 opPerformed, true);
  if (result != returnvalue::OK) {
    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
  }
@ -254,8 +239,8 @@ void Q7STestTask::testProtHandler() {
  }

  // lock own copy
-  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::SELF_CHIP,
-                                                              xsc::Copy::SELF_COPY, true);
+  result = coreController->setBootCopyProtection(xsc::Chip::SELF_CHIP, xsc::Copy::SELF_COPY, true,
+                                                 opPerformed, true);
  if (result != returnvalue::OK) {
    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
  }
@ -268,8 +253,8 @@ void Q7STestTask::testProtHandler() {
  }

  // unlock specific copy
-  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::CHIP_1, xsc::Copy::COPY_1,
-                                                              false);
+  result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, false,
+                                                 opPerformed, true);
  if (result != returnvalue::OK) {
    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
  }
@ -282,8 +267,8 @@ void Q7STestTask::testProtHandler() {
  }

  // lock specific copy
-  result = coreController->setBootCopyProtectionAndUpdateFile(xsc::Chip::CHIP_1, xsc::Copy::COPY_1,
-                                                              true);
+  result = coreController->setBootCopyProtection(xsc::Chip::CHIP_1, xsc::Copy::COPY_1, true,
+                                                 opPerformed, true);
  if (result != returnvalue::OK) {
    sif::warning << "Q7STestTask::testProtHandler: Op failed" << std::endl;
  }
--- a/bsp_q7s/core/CMakeLists.txt
+++ b/bsp_q7s/core/CMakeLists.txt
@ -1 +1,4 @@
-target_sources(${OBSW_NAME} PRIVATE CoreController.cpp WatchdogHandler.cpp)
+target_sources(${OBSW_NAME} PRIVATE CoreController.cpp scheduling.cpp
+                                    ObjectFactory.cpp WatchdogHandler.cpp)
+
+target_sources(${SIMPLE_OBSW_NAME} PRIVATE scheduling.cpp)
--- a/bsp_q7s/core/CoreController.cpp
+++ b/bsp_q7s/core/CoreController.cpp
--- a/bsp_q7s/core/CoreController.h
+++ b/bsp_q7s/core/CoreController.h
@ -1,13 +1,11 @@
 #ifndef BSP_Q7S_CORE_CORECONTROLLER_H_
 #define BSP_Q7S_CORE_CORECONTROLLER_H_

-#include <bsp_q7s/core/defs.h>
 #include <fsfw/container/DynamicFIFO.h>
 #include <fsfw/container/SimpleRingBuffer.h>
 #include <fsfw/globalfunctions/PeriodicOperationDivider.h>
 #include <fsfw/parameters/ParameterHelper.h>
 #include <fsfw/parameters/ReceivesParameterMessagesIF.h>
-#include <fsfw_hal/linux/uio/UioMapper.h>
 #include <libxiphos.h>
 #include <mission/acs/archive/GPSDefinitions.h>
 #include <mission/utility/trace.h>
@ -15,6 +13,7 @@
 #include <atomic>
 #include <cstddef>

+#include "CoreDefinitions.h"
 #include "OBSWConfig.h"
 #include "bsp_q7s/fs/SdCardManager.h"
 #include "events/subsystemIdRanges.h"
@ -24,7 +23,7 @@
 class Timer;
 class SdCardManager;

-struct RebootWatchdogFile {
+struct RebootFile {
  static constexpr uint8_t DEFAULT_MAX_BOOT_CNT = 10;

  bool enabled = true;
@ -45,93 +44,6 @@ struct RebootWatchdogFile {
  xsc::Copy mechanismNextCopy = xsc::Copy::NO_COPY;
 };

-class RebootWatchdogPacket : public SerialLinkedListAdapter<SerializeIF> {
- public:
-  RebootWatchdogPacket(RebootWatchdogFile& rf) {
-    enabled = rf.enabled;
-    maxCount = rf.maxCount;
-    img00Count = rf.img00Cnt;
-    img01Count = rf.img01Cnt;
-    img10Count = rf.img10Cnt;
-    img11Count = rf.img11Cnt;
-    img00Lock = rf.img00Lock;
-    img01Lock = rf.img01Lock;
-    img10Lock = rf.img10Lock;
-    img11Lock = rf.img11Lock;
-    lastChip = static_cast<uint8_t>(rf.lastChip);
-    lastCopy = static_cast<uint8_t>(rf.lastCopy);
-    nextChip = static_cast<uint8_t>(rf.mechanismNextChip);
-    nextCopy = static_cast<uint8_t>(rf.mechanismNextCopy);
-    setLinks();
-  }
-
- private:
-  void setLinks() {
-    setStart(&enabled);
-    enabled.setNext(&maxCount);
-    maxCount.setNext(&img00Count);
-    img00Count.setNext(&img01Count);
-    img01Count.setNext(&img10Count);
-    img10Count.setNext(&img11Count);
-    img11Count.setNext(&img00Lock);
-    img00Lock.setNext(&img01Lock);
-    img01Lock.setNext(&img10Lock);
-    img10Lock.setNext(&img11Lock);
-    img11Lock.setNext(&lastChip);
-    lastChip.setNext(&lastCopy);
-    lastCopy.setNext(&nextChip);
-    nextChip.setNext(&nextCopy);
-    setLast(&nextCopy);
-  }
-
-  SerializeElement<uint8_t> enabled = false;
-  SerializeElement<uint32_t> maxCount = 0;
-  SerializeElement<uint32_t> img00Count = 0;
-  SerializeElement<uint32_t> img01Count = 0;
-  SerializeElement<uint32_t> img10Count = 0;
-  SerializeElement<uint32_t> img11Count = 0;
-  SerializeElement<uint8_t> img00Lock = false;
-  SerializeElement<uint8_t> img01Lock = false;
-  SerializeElement<uint8_t> img10Lock = false;
-  SerializeElement<uint8_t> img11Lock = false;
-  SerializeElement<uint8_t> lastChip = 0;
-  SerializeElement<uint8_t> lastCopy = 0;
-  SerializeElement<uint8_t> nextChip = 0;
-  SerializeElement<uint8_t> nextCopy = 0;
-};
-
-struct RebootCountersFile {
-  // 16 bit values so all boot counters fit into one event.
-  uint16_t img00Cnt = 0;
-  uint16_t img01Cnt = 0;
-  uint16_t img10Cnt = 0;
-  uint16_t img11Cnt = 0;
-};
-
-class RebootCountersPacket : public SerialLinkedListAdapter<SerializeIF> {
-  RebootCountersPacket(RebootCountersFile& rf) {
-    img00Count = rf.img00Cnt;
-    img01Count = rf.img01Cnt;
-    img10Count = rf.img10Cnt;
-    img11Count = rf.img11Cnt;
-    setLinks();
-  }
-
- private:
-  void setLinks() {
-    setStart(&img00Count);
-    img00Count.setNext(&img01Count);
-    img01Count.setNext(&img10Count);
-    img10Count.setNext(&img11Count);
-    setLast(&img11Count);
-  }
-
-  SerializeElement<uint16_t> img00Count = 0;
-  SerializeElement<uint16_t> img01Count = 0;
-  SerializeElement<uint16_t> img10Count = 0;
-  SerializeElement<uint16_t> img11Count = 0;
-};
-
 class CoreController : public ExtendedControllerBase, public ReceivesParameterMessagesIF {
 public:
  enum ParamId : uint8_t { PREF_SD = 0, NUM_IDS };
@ -145,15 +57,10 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe

  const std::string VERSION_FILE =
      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::VERSION_FILE_NAME);
-  const std::string LEGACY_REBOOT_WATCHDOG_FILE =
-      "/" + std::string(core::CONF_FOLDER) + "/" +
-      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 REBOOT_FILE =
+      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::REBOOT_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 =
-      "/" + std::string(core::CONF_FOLDER) + "/" + std::string(core::REBOOT_COUNTER_FILE_NAME);

  static constexpr char CHIP_0_COPY_0_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-nom-rootfs";
  static constexpr char CHIP_0_COPY_1_MOUNT_DIR[] = "/tmp/mntupdate-xdi-qspi0-gold-rootfs";
@ -199,8 +106,8 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
   * @param updateProtFile Specify whether the protection info file is updated
   * @return
   */
-  ReturnValue_t setBootCopyProtectionAndUpdateFile(xsc::Chip targetChip, xsc::Copy targetCopy,
-                                                   bool protect);
+  ReturnValue_t setBootCopyProtection(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
+                                      bool& protOperationPerformed, bool updateProtFile = true);

  bool sdInitFinished() const;

@ -235,7 +142,6 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe

  static constexpr bool BLOCKING_SD_INIT = false;

-  uint32_t* mappedSysRomAddr = nullptr;
  SdCardManager* sdcMan = nullptr;
  MessageQueueIF* eventQueue = nullptr;

@ -285,8 +191,7 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
  std::array<uint8_t, 1024> dirListingBuf{};
  DirListingDumpContext dumpContext{};

-  RebootWatchdogFile rebootWatchdogFile = {};
-  RebootCountersFile rebootCountersFile = {};
+  RebootFile rebootFile = {};

  CommandExecutor cmdExecutor;
  SimpleRingBuffer cmdReplyBuf;
@ -304,10 +209,12 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
  Countdown sdCardCheckCd = Countdown(INIT_SD_CARD_CHECK_TIMEOUT);

  /**
-   * First index: Chip.
-   * Second index: Copy.
+   * Index 0: Chip 0 Copy 0
+   * Index 1: Chip 0 Copy 1
+   * Index 2: Chip 1 Copy 0
+   * Index 3: Chip 1 Copy 1
   */
-  bool protArray[2][2]{};
+  std::array<bool, 4> protArray;
  PeriodicOperationDivider opDivider5;
  PeriodicOperationDivider opDivider10;

@ -354,14 +261,12 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
  void currentStateSetter(sd::SdCard sdCard, sd::SdState newState);
  void executeNextExternalSdCommand();
  void checkExternalSdCommandStatus();
-  void performRebootWatchdogHandling(bool recreateFile);
-  void performRebootCountersHandling(bool recreateFile);
+  void performRebootFileHandling(bool recreateFile);

  ReturnValue_t actionListDirectoryIntoFile(ActionId_t actionId, MessageQueueId_t commandedBy,
                                            const uint8_t* data, size_t size);
  ReturnValue_t actionListDirectoryDumpDirectly(ActionId_t actionId, MessageQueueId_t commandedBy,
                                                const uint8_t* data, size_t size);
-  ReturnValue_t performGracefulShutdown(xsc::Chip targetChip, xsc::Copy targetCopy);

  ReturnValue_t actionListDirectoryCommonCommandCreator(const uint8_t* data, size_t size,
                                                        std::ostringstream& oss);
@ -372,20 +277,16 @@ class CoreController : public ExtendedControllerBase, public ReceivesParameterMe
  ReturnValue_t gracefulShutdownTasks(xsc::Chip chip, xsc::Copy copy, bool& protOpPerformed);

  ReturnValue_t handleProtInfoUpdateLine(std::string nextLine);
-  ReturnValue_t handleSwitchingSdCardsOffNonBlocking();
-  bool handleBootCopyProt(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect);
-  void rebootWatchdogAlgorithm(RebootWatchdogFile& rf, bool& needsReboot, xsc::Chip& tgtChip,
-                               xsc::Copy& tgtCopy);
-  void resetRebootWatchdogCounters(xsc::Chip tgtChip, xsc::Copy tgtCopy);
+  int handleBootCopyProtAtIndex(xsc::Chip targetChip, xsc::Copy targetCopy, bool protect,
+                                bool& protOperationPerformed, bool selfChip, bool selfCopy,
+                                bool allChips, bool allCopies, uint8_t arrIdx);
+  void determineAndExecuteReboot(RebootFile& rf, bool& needsReboot, xsc::Chip& tgtChip,
+                                 xsc::Copy& tgtCopy);
+  void resetRebootCount(xsc::Chip tgtChip, xsc::Copy tgtCopy);
  void setRebootMechanismLock(bool lock, xsc::Chip tgtChip, xsc::Copy tgtCopy);
-  bool parseRebootWatchdogFile(std::string path, RebootWatchdogFile& file);
-  bool parseRebootCountersFile(std::string path, RebootCountersFile& file);
-  void rewriteRebootWatchdogFile(RebootWatchdogFile file);
-  void rewriteRebootCountersFile(RebootCountersFile file);
+  bool parseRebootFile(std::string path, RebootFile& file);
+  void rewriteRebootFile(RebootFile file);
  void announceBootCounts();
-  void announceVersionInfo();
-  void announceCurrentImageInfo();
-  void announceSdInfo(SdCardManager::SdStatePair sdStates);
  void readHkData();
  void dirListingDumpHandler();
  bool isNumber(const std::string& s);
--- a/bsp_q7s/core/CoreDefinitions.h
+++ b/bsp_q7s/core/CoreDefinitions.h
@ -1,16 +1,10 @@
-#ifndef BSP_Q7S_CORE_DEFS_H_
-#define BSP_Q7S_CORE_DEFS_H_
+#ifndef BSP_Q7S_CORE_COREDEFINITIONS_H_
+#define BSP_Q7S_CORE_COREDEFINITIONS_H_

 #include <fsfw/datapoollocal/StaticLocalDataSet.h>

 namespace core {

-extern uint8_t FW_VERSION_MAJOR;
-extern uint8_t FW_VERSION_MINOR;
-extern uint8_t FW_VERSION_REVISION;
-extern bool FW_VERSION_HAS_SHA;
-extern char FW_VERSION_GIT_SHA[4];
-
 static const uint8_t HK_SET_ENTRIES = 3;
 static const uint32_t HK_SET_ID = 5;

@ -42,4 +36,4 @@ class HkSet : public StaticLocalDataSet<HK_SET_ENTRIES> {

 }  // namespace core

-#endif /* BSP_Q7S_CORE_DEFS_H_ */
+#endif /* BSP_Q7S_CORE_COREDEFINITIONS_H_ */
--- a/bsp_q7s/core/ObjectFactory.cpp
+++ b/bsp_q7s/core/ObjectFactory.cpp
@ -1,9 +1,7 @@
-#include "objectFactory.h"
+#include "ObjectFactory.h"

 #include <fsfw/devicehandlers/HealthDevice.h>
 #include <fsfw/subsystem/Subsystem.h>
-#include <fsfw/tasks/TaskFactory.h>
-#include <fsfw_hal/linux/uio/UioMapper.h>
 #include <linux/acs/AcsBoardPolling.h>
 #include <linux/acs/GpsHyperionLinuxController.h>
 #include <linux/acs/ImtqPollingTask.h>
@ -33,9 +31,6 @@
 #include <mission/system/objects/CamSwitcher.h>
 #include <mission/system/tcs/TmpDevFdir.h>

-#include <cstdint>
-#include <cstring>
-
 #include "OBSWConfig.h"
 #include "bsp_q7s/boardtest/Q7STestTask.h"
 #include "bsp_q7s/callbacks/gnssCallback.h"
@ -104,7 +99,6 @@

 #include <sstream>

-#include "bsp_q7s/core/defs.h"
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
 #include "fsfw/tmtcpacket/pus/tm.h"
 #include "fsfw/tmtcservices/CommandingServiceBase.h"
@ -135,11 +129,6 @@ ResetArgs RESET_ARGS_GNSS;
 std::atomic_bool LINK_STATE = CcsdsIpCoreHandler::LINK_DOWN;
 std::atomic_bool PTME_LOCKED = false;
 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;
-bool core::FW_VERSION_HAS_SHA = false;
-char core::FW_VERSION_GIT_SHA[4] = {};

 void Factory::setStaticFrameworkObjectIds() {
  PusServiceBase::PUS_DISTRIBUTOR = objects::PUS_PACKET_DISTRIBUTOR;
@ -161,23 +150,28 @@ void Factory::setStaticFrameworkObjectIds() {

 void ObjectFactory::setStatics() { Factory::setStaticFrameworkObjectIds(); }

-void ObjectFactory::createTmpComponents(
-    std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd) {
-  const char* tmpI2cDev = q7s::I2C_PS_EIVE;
-  if (core::FW_VERSION_MAJOR == 4) {
-    tmpI2cDev = q7s::I2C_PL_EIVE;
-  } else if (core::FW_VERSION_MAJOR >= 5) {
-    tmpI2cDev = q7s::I2C_Q7_EIVE;
-  }
+void ObjectFactory::createTmpComponents() {
+  std::vector<std::pair<object_id_t, address_t>> tmpDevIds = {{
+      {objects::TMP1075_HANDLER_TCS_0, addresses::TMP1075_TCS_0},
+      {objects::TMP1075_HANDLER_TCS_1, addresses::TMP1075_TCS_1},
+      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
+      // damaged
+      // {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
+      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
+  }};
  std::vector<I2cCookie*> tmpDevCookies;

-  for (size_t idx = 0; idx < tmpDevsToAdd.size(); idx++) {
+  for (size_t idx = 0; idx < tmpDevIds.size(); idx++) {
    tmpDevCookies.push_back(
-        new I2cCookie(tmpDevsToAdd[idx].second, TMP1075::MAX_REPLY_LENGTH, tmpI2cDev));
+        new I2cCookie(tmpDevIds[idx].second, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_PS_EIVE));
    auto* tmpDevHandler =
-        new Tmp1075Handler(tmpDevsToAdd[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
-    tmpDevHandler->setCustomFdir(new TmpDevFdir(tmpDevsToAdd[idx].first));
+        new Tmp1075Handler(tmpDevIds[idx].first, objects::I2C_COM_IF, tmpDevCookies[idx]);
+    tmpDevHandler->setCustomFdir(new TmpDevFdir(tmpDevIds[idx].first));
    tmpDevHandler->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
+    // TODO: Remove this after TCS subsystem was added
+    // These devices are connected to the 3V3 stack and should be powered permanently. Therefore,
+    // we set them to normal mode immediately here.
+    tmpDevHandler->setModeNormal();
  }
 }

@ -249,7 +243,7 @@ ReturnValue_t ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF,
  createRadSensorChipSelect(gpioComIF);

  SpiCookie* spiCookieRadSensor =
-      new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, radSens::READ_SIZE,
+      new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, RAD_SENSOR::READ_SIZE,
                    spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
  spiCookieRadSensor->setMutexParams(MutexIF::TimeoutType::WAITING, spi::RAD_SENSOR_CS_TIMEOUT);
  auto radSensor = new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_MAIN_COM_IF,
@ -511,7 +505,7 @@ void ObjectFactory::createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF*
  debugGps = true;
 #endif
  RESET_ARGS_GNSS.gpioComIF = gpioComIF;
-  RESET_ARGS_GNSS.waitPeriodMs = 5;
+  RESET_ARGS_GNSS.waitPeriodMs = 100;
  auto gpsCtrl = new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT,
                                                enableHkSets, debugGps);
  gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);
@ -736,12 +730,20 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
  // GPIO definitions of signals connected to the virtual channel interfaces of the PTME IP Core
  GpioCookie* gpioCookiePtmeIp = new GpioCookie;
  GpiodRegularByLineName* gpio = nullptr;
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC0, "PAPB VC0");
+  gpioCookiePtmeIp->addGpio(gpioIds::VC0_PAPB_BUSY, gpio);
  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC0, "PAPB VC0");
  gpioCookiePtmeIp->addGpio(gpioIds::VC0_PAPB_EMPTY, gpio);
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC1, "PAPB VC1");
+  gpioCookiePtmeIp->addGpio(gpioIds::VC1_PAPB_BUSY, gpio);
  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC1, "PAPB VC1");
  gpioCookiePtmeIp->addGpio(gpioIds::VC1_PAPB_EMPTY, gpio);
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC2, "PAPB VC2");
+  gpioCookiePtmeIp->addGpio(gpioIds::VC2_PAPB_BUSY, gpio);
  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC2, "PAPB VC2");
  gpioCookiePtmeIp->addGpio(gpioIds::VC2_PAPB_EMPTY, gpio);
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_BUSY_SIGNAL_VC3, "PAPB VC3");
+  gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_BUSY, gpio);
  gpio = new GpiodRegularByLineName(q7s::gpioNames::PAPB_EMPTY_SIGNAL_VC3, "PAPB VC3");
  gpioCookiePtmeIp->addGpio(gpioIds::VC3_PAPB_EMPTY, gpio);
  gpio = new GpiodRegularByLineName(q7s::gpioNames::PTME_RESETN, "PTME RESETN",
@ -750,14 +752,18 @@ ReturnValue_t ObjectFactory::createCcsdsComponents(CcsdsComponentArgs& args) {
  gpioChecker(args.gpioComIF.addGpios(gpioCookiePtmeIp), "PTME PAPB VCs");

  // Creating virtual channel interfaces
-  VirtualChannelIF* vc0 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_EMPTY,
-                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC0);
-  VirtualChannelIF* vc1 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_EMPTY,
-                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC1);
-  VirtualChannelIF* vc2 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_EMPTY,
-                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC2);
-  VirtualChannelIF* vc3 = new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_EMPTY,
-                                              q7s::UIO_PTME, q7s::uiomapids::PTME_VC3);
+  VirtualChannelIF* vc0 =
+      new PapbVcInterface(&args.gpioComIF, gpioIds::VC0_PAPB_BUSY, gpioIds::VC0_PAPB_EMPTY,
+                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC0);
+  VirtualChannelIF* vc1 =
+      new PapbVcInterface(&args.gpioComIF, gpioIds::VC1_PAPB_BUSY, gpioIds::VC1_PAPB_EMPTY,
+                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC1);
+  VirtualChannelIF* vc2 =
+      new PapbVcInterface(&args.gpioComIF, gpioIds::VC2_PAPB_BUSY, gpioIds::VC2_PAPB_EMPTY,
+                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC2);
+  VirtualChannelIF* vc3 =
+      new PapbVcInterface(&args.gpioComIF, gpioIds::VC3_PAPB_BUSY, gpioIds::VC3_PAPB_EMPTY,
+                          q7s::UIO_PTME, q7s::uiomapids::PTME_VC3);
  // Creating ptme object and adding virtual channel interfaces
  Ptme* ptme = new Ptme(objects::PTME);
  ptme->addVcInterface(ccsds::VC0, vc0);
@ -937,7 +943,16 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
  starTrackerCookie->setNoFixedSizeReply();
  StrComHandler* strComIF = new StrComHandler(objects::STR_COM_IF);

-  const char* paramJsonFile = "/mnt/sd0/startracker/flight-config.json";
+  const char* paramJsonFile = nullptr;
+#ifdef EGSE
+  paramJsonFile = "/home/pi/arcsec/json/flight-config.json";
+#else
+#if OBSW_STAR_TRACKER_GROUND_CONFIG == 1
+  paramJsonFile = "/mnt/sd0/startracker/ground-config.json";
+#else
+  paramJsonFile = "/mnt/sd0/startracker/flight-config.json";
+#endif
+#endif
  if (paramJsonFile == nullptr) {
    sif::error << "No valid Star Tracker parameter JSON file" << std::endl;
  }
@ -950,13 +965,12 @@ void ObjectFactory::createStrComponents(PowerSwitchIF* pwrSwitcher) {
  starTracker->setCustomFdir(strFdir);
 }

-void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets,
-                                         const char* i2cDev) {
+void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets) {
  auto* imtqAssy = new ImtqAssembly(objects::IMTQ_ASSY);
  imtqAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);

  new ImtqPollingTask(objects::IMTQ_POLLING, I2C_FATAL_ERRORS);
-  I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, imtq::MAX_REPLY_SIZE, i2cDev);
+  I2cCookie* imtqI2cCookie = new I2cCookie(addresses::IMTQ, imtq::MAX_REPLY_SIZE, q7s::I2C_PL_EIVE);
  auto imtqHandler = new ImtqHandler(objects::IMTQ_HANDLER, objects::IMTQ_POLLING, imtqI2cCookie,
                                     power::Switches::PDU1_CH3_MGT_5V, enableHkSets);
  imtqHandler->enableThermalModule(ThermalStateCfg());
@ -972,8 +986,8 @@ void ObjectFactory::createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enable
 #endif
 }

-void ObjectFactory::createBpxBatteryComponent(bool enableHkSets, const char* i2cDev) {
-  I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, i2cDev);
+void ObjectFactory::createBpxBatteryComponent(bool enableHkSets) {
+  I2cCookie* bpxI2cCookie = new I2cCookie(addresses::BPX_BATTERY, 100, q7s::I2C_PL_EIVE);
  BpxBatteryHandler* bpxHandler = new BpxBatteryHandler(
      objects::BPX_BATT_HANDLER, objects::I2C_COM_IF, bpxI2cCookie, enableHkSets);
  bpxHandler->setStartUpImmediately();
@ -1011,50 +1025,3 @@ void ObjectFactory::createRadSensorChipSelect(LinuxLibgpioIF* gpioIF) {
  gpioCookieRadSensor->addGpio(gpioIds::ENABLE_RADFET, gpio);
  gpioChecker(gpioIF->addGpios(gpioCookieRadSensor), "RAD sensor");
 }
-
-void ObjectFactory::createPlI2cResetGpio(LinuxLibgpioIF* gpioIF) {
-  using namespace gpio;
-  if (common::OBSW_VERSION_MAJOR >= 6 or common::OBSW_VERSION_MAJOR == 4) {
-    if (gpioIF == nullptr) {
-      return;
-    }
-    GpioCookie* gpioI2cResetnCookie = new GpioCookie;
-    GpiodRegularByLineName* gpioI2cResetn = new GpiodRegularByLineName(
-        q7s::gpioNames::PL_I2C_ARESETN, "PL_I2C_ARESETN", Direction::OUT, Levels::HIGH);
-    gpioI2cResetnCookie->addGpio(gpioIds::PL_I2C_ARESETN, gpioI2cResetn);
-    gpioChecker(gpioIF->addGpios(gpioI2cResetnCookie), "PL I2C ARESETN");
-    // Reset I2C explicitely again.
-    gpioIF->pullLow(gpioIds::PL_I2C_ARESETN);
-    TaskFactory::delayTask(1);
-    gpioIF->pullHigh(gpioIds::PL_I2C_ARESETN);
-  }
-}
-
-ReturnValue_t ObjectFactory::readFirmwareVersion() {
-  uint32_t* mappedSysRomAddr = nullptr;
-  // The SYS ROM FPGA block is only available in those versions.
-  if (not(common::OBSW_VERSION_MAJOR >= 6) or (common::OBSW_VERSION_MAJOR == 4)) {
-    return returnvalue::OK;
-  }
-  // This has to come before the version announce because it might be required for retrieving
-  // the firmware version.
-  UioMapper sysRomMapper(q7s::UIO_SYS_ROM);
-  ReturnValue_t result =
-      sysRomMapper.getMappedAdress(&mappedSysRomAddr, UioMapper::Permissions::READ_ONLY);
-  if (result != returnvalue::OK) {
-    sif::error << "Getting mapped SYS ROM UIO address failed" << std::endl;
-    return returnvalue::FAILED;
-  }
-  if (mappedSysRomAddr != nullptr) {
-    uint32_t firstEntry = *(reinterpret_cast<uint32_t*>(mappedSysRomAddr));
-    uint32_t secondEntry = *(reinterpret_cast<uint32_t*>(mappedSysRomAddr) + 1);
-    core::FW_VERSION_MAJOR = (firstEntry >> 24) & 0xff;
-    core::FW_VERSION_MINOR = (firstEntry >> 16) & 0xff;
-    core::FW_VERSION_REVISION = (firstEntry >> 8) & 0xff;
-    bool hasGitSha = (firstEntry & 0x0b1);
-    if (hasGitSha) {
-      std::memcpy(core::FW_VERSION_GIT_SHA, &secondEntry, 4);
-    }
-  }
-  return returnvalue::OK;
-}
--- a/bsp_q7s/core/ObjectFactory.h
+++ b/bsp_q7s/core/ObjectFactory.h
@ -58,7 +58,7 @@ void createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher
                          bool enableHkSets);
 void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
                            PowerSwitchIF* pwrSwitcher, Stack5VHandler& stackHandler);
-void createTmpComponents(std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd);
+void createTmpComponents();
 void createRadSensorChipSelect(LinuxLibgpioIF* gpioIF);
 ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF, Stack5VHandler& handler);
 void createAcsBoardGpios(GpioCookie& cookie);
@ -67,19 +67,17 @@ void createAcsBoardComponents(SpiComIF& spiComIF, LinuxLibgpioIF* gpioComIF, Ser
                              adis1650x::Type adisType);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable,
                            HeaterHandler*& heaterHandler);
-void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets, const char* i2cDev);
-void createBpxBatteryComponent(bool enableHkSets, const char* i2cDev);
+void createImtqComponents(PowerSwitchIF* pwrSwitcher, bool enableHkSets);
+void createBpxBatteryComponent(bool enableHkSets);
 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 createCcsdsComponents(CcsdsComponentArgs& args);
-ReturnValue_t readFirmwareVersion();
 void createMiscComponents();

 void createTestComponents(LinuxLibgpioIF* gpioComIF);
-void createPlI2cResetGpio(LinuxLibgpioIF* gpioComIF);

 void testAcsBrdAss(AcsBoardAssembly* assAss);

--- a/bsp_q7s/core/scheduling.cpp
+++ b/bsp_q7s/core/scheduling.cpp
@ -9,6 +9,7 @@
 #include <vector>

 #include "OBSWConfig.h"
+#include "bsp_q7s/core/ObjectFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/objectmanager/ObjectManagerIF.h"
 #include "fsfw/platform.h"
@ -20,8 +21,6 @@
 #include "mission/pollingSeqTables.h"
 #include "mission/scheduling.h"
 #include "mission/utility/InitMission.h"
-#include "objectFactory.h"
-#include "q7sConfig.h"

 /* This is configured for linux without CR */
 #ifdef PLATFORM_UNIX
@ -325,10 +324,6 @@ void scheduling::initTasks() {
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
  }
-  result = tcsSystemTask->addComponent(objects::HEATER_HANDLER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("HEATER_HANDLER", objects::HEATER_HANDLER);
-  }

 #if OBSW_ADD_SYRLINKS == 1
  PeriodicTaskIF* syrlinksCom = factory->createPeriodicTask(
@ -532,15 +527,7 @@ void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction
  FixedTimeslotTaskIF* i2cPst =
      factory.createFixedTimeslotTask("I2C_PS_PST", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 0.6,
                                      missedDeadlineFunc, &RR_SCHEDULING);
-  pst::TmpSchedConfig tmpSchedConf;
-#if OBSW_Q7S_EM == 1
-  tmpSchedConf.scheduleTmpDev0 = true;
-  tmpSchedConf.scheduleTmpDev1 = true;
-  tmpSchedConf.schedulePlPcduDev0 = true;
-  tmpSchedConf.schedulePlPcduDev1 = true;
-  tmpSchedConf.scheduleIfBoardDev = true;
-#endif
-  result = pst::pstI2c(tmpSchedConf, i2cPst);
+  result = pst::pstI2cProcessingSystem(i2cPst);
  if (result != returnvalue::OK) {
    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
      sif::warning << "scheduling::initTasks: I2C PST is empty" << std::endl;
--- a/bsp_q7s/core/scheduling.h
+++ b/bsp_q7s/core/scheduling.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/objectFactory.h>
 #include <dummies/ComCookieDummy.h>
 #include <dummies/PcduHandlerDummy.h>
 #include <fsfw/health/HealthTableIF.h>
@ -11,8 +10,8 @@

 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
+#include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
-#include "common/config/devices/addresses.h"
 #include "devConf.h"
 #include "dummies/helperFactory.h"
 #include "eive/objects.h"
@ -36,20 +35,18 @@ void ObjectFactory::produce(void* args) {
 #endif

  PersistentTmStores stores;
-  readFirmwareVersion();
  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
-                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores, 200,
-                                       enableHkSets);
+                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores,
+                                       200);

  LinuxLibgpioIF* gpioComIF = nullptr;
  SerialComIF* uartComIF = nullptr;
  SpiComIF* spiMainComIF = nullptr;
  I2cComIF* i2cComIF = nullptr;
  createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiMainComIF, &i2cComIF);
-  // Adding GPIOs for chip select decoding and initializing them.
+  /* Adding gpios for chip select decoding to the gpioComIf */
  q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
  gpioCallbacks::disableAllDecoder(gpioComIF);
-  createPlI2cResetGpio(gpioComIF);

  // Hardware is usually not connected to EM, so we need to create dummies which replace lower
  // level components.
@ -62,32 +59,11 @@ void ObjectFactory::produce(void* args) {
 #if OBSW_ADD_PLOC_SUPERVISOR == 1 || OBSW_ADD_PLOC_MPSOC == 1
  dummyCfg.addPlocDummies = false;
 #endif
-#if OBSW_ADD_TMP_DEVICES == 1
-  std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd = {{
-      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
-      {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
-      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
-  }};
-  createTmpComponents(tmpDevsToAdd);
-  dummy::Tmp1075Cfg tmpCfg{};
-  tmpCfg.addTcsBrd0 = true;
-  tmpCfg.addTcsBrd1 = true;
-  tmpCfg.addPlPcdu0 = false;
-  tmpCfg.addPlPcdu1 = false;
-  tmpCfg.addIfBrd = false;
-  dummyCfg.tmp1075Cfg = tmpCfg;
-#endif
 #if OBSW_ADD_GOMSPACE_PCDU == 1
  dummyCfg.addPowerDummies = false;
  // The ACU broke.
  dummyCfg.addOnlyAcuDummy = true;
 #endif
-#if OBSW_ADD_STAR_TRACKER == 1
-  dummyCfg.addStrDummy = false;
-#endif
-#if OBSW_ADD_SCEX_DEVICE == 0
-  dummyCfg.addScexDummy = true;
-#endif
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
  dummyCfg.addBpxBattDummy = false;
 #endif
@ -107,10 +83,24 @@ void ObjectFactory::produce(void* args) {

  new CoreController(objects::CORE_CONTROLLER, enableHkSets);

-  // Initialize chip select to avoid SPI bus issues.
-  createRadSensorChipSelect(gpioComIF);
+  // Regular FM code, does not work for EM if the hardware is not connected
+  // createPcduComponents(gpioComIF, &pwrSwitcher);
+  // createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher);
+  // createSyrlinksComponents(pwrSwitcher);
+  // createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
+  // createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
+  // createTmpComponents();
+  // createSolarArrayDeploymentComponents();
+  // createPayloadComponents(gpioComIF);
+  // createHeaterComponents(gpioComIF, pwrSwitcher, healthTable);
+
+  // TODO: Careful! Switching this on somehow messes with the communication with the ProASIC
+  //       and will cause xsc_boot_copy commands to always boot to 0 0
+  // createRadSensorComponent(gpioComIF);

 #if OBSW_ADD_ACS_BOARD == 1
+  // Still initialize chip select to avoid SPI bus issues.
+  createRadSensorChipSelect(gpioComIF);
  createAcsBoardComponents(*spiMainComIF, gpioComIF, uartComIF, *pwrSwitcher, true,
                           adis1650x::Type::ADIS16507);
 #else
@ -120,14 +110,8 @@ 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);
+  createImtqComponents(pwrSwitcher, enableHkSets);
 #endif

 #if OBSW_ADD_SYRLINKS == 1
@ -139,7 +123,7 @@ void ObjectFactory::produce(void* args) {
 #endif

 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
-  createBpxBatteryComponent(enableHkSets, battAndImtqI2cDev);
+  createBpxBatteryComponent(enableHkSets);
 #endif

 #if OBSW_ADD_STAR_TRACKER == 1
@ -171,6 +155,6 @@ void ObjectFactory::produce(void* args) {
  createAcsController(true, enableHkSets);
  HeaterHandler* heaterHandler;
  createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
-  createThermalController(*heaterHandler, true);
-  satsystem::init(true);
+  createThermalController(*heaterHandler);
+  satsystem::init();
 }
--- a/bsp_q7s/fmObjectFactory.cpp
+++ b/bsp_q7s/fmObjectFactory.cpp
@ -1,5 +1,4 @@
 #include <bsp_q7s/callbacks/q7sGpioCallbacks.h>
-#include <bsp_q7s/objectFactory.h>
 #include <devices/gpioIds.h>
 #include <fsfw/storagemanager/LocalPool.h>
 #include <fsfw/storagemanager/PoolManager.h>
@ -8,9 +7,9 @@

 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
+#include "bsp_q7s/core/ObjectFactory.h"
 #include "busConf.h"
 #include "devConf.h"
-#include "devices/addresses.h"
 #include "eive/objects.h"
 #include "fsfw_hal/linux/gpio/LinuxLibgpioIF.h"
 #include "linux/ObjectFactory.h"
@ -33,10 +32,9 @@ void ObjectFactory::produce(void* args) {
 #endif

  PersistentTmStores stores;
-  readFirmwareVersion();
  ObjectFactory::produceGenericObjects(&healthTable, &pusFunnel, &cfdpFunnel,
-                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores, 200,
-                                       true);
+                                       *SdCardManager::instance(), &ipcStore, &tmStore, stores,
+                                       200);

  LinuxLibgpioIF* gpioComIF = nullptr;
  SerialComIF* uartComIF = nullptr;
@ -47,7 +45,6 @@ void ObjectFactory::produce(void* args) {
  /* Adding gpios for chip select decoding to the gpioComIf */
  q7s::gpioCallbacks::initSpiCsDecoder(gpioComIF);
  gpioCallbacks::disableAllDecoder(gpioComIF);
-  createPlI2cResetGpio(gpioComIF);

  new CoreController(objects::CORE_CONTROLLER, enableHkSets);
  createPcduComponents(gpioComIF, &pwrSwitcher, enableHkSets);
@ -69,16 +66,7 @@ void ObjectFactory::produce(void* args) {
  HeaterHandler* heaterHandler;
  createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
 #if OBSW_ADD_TMP_DEVICES == 1
-  std::vector<std::pair<object_id_t, address_t>> tmpDevsToAdd = {{
-      {objects::TMP1075_HANDLER_TCS_0, addresses::TMP1075_TCS_0},
-      {objects::TMP1075_HANDLER_TCS_1, addresses::TMP1075_TCS_1},
-      {objects::TMP1075_HANDLER_PLPCDU_0, addresses::TMP1075_PLPCDU_0},
-      // damaged
-      // {objects::TMP1075_HANDLER_PLPCDU_1, addresses::TMP1075_PLPCDU_1},
-      {objects::TMP1075_HANDLER_IF_BOARD, addresses::TMP1075_IF_BOARD},
-  }};
-
-  createTmpComponents(tmpDevsToAdd);
+  createTmpComponents();
 #endif
  createSolarArrayDeploymentComponents(*pwrSwitcher, *gpioComIF);
  createPlPcduComponents(gpioComIF, spiMainComIF, pwrSwitcher, *stackHandler);
@ -88,17 +76,13 @@ void ObjectFactory::produce(void* args) {
  createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher, spiMainComIF);
  createPayloadComponents(gpioComIF, *pwrSwitcher);

-  const char* battAndImtqI2cDev = q7s::I2C_PL_EIVE;
-  if (core::FW_VERSION_MAJOR >= 4) {
-    battAndImtqI2cDev = q7s::I2C_PS_EIVE;
-  }
 #if OBSW_ADD_MGT == 1
-  createImtqComponents(pwrSwitcher, enableHkSets, battAndImtqI2cDev);
+  createImtqComponents(pwrSwitcher, enableHkSets);
 #endif
  createReactionWheelComponents(gpioComIF, pwrSwitcher);

 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
-  createBpxBatteryComponent(enableHkSets, battAndImtqI2cDev);
+  createBpxBatteryComponent(enableHkSets);
 #endif

 #if OBSW_ADD_STAR_TRACKER == 1
@ -128,7 +112,7 @@ void ObjectFactory::produce(void* args) {
 #endif /* OBSW_ADD_TEST_CODE == 1 */

  createMiscComponents();
-  createThermalController(*heaterHandler, false);
+  createThermalController(*heaterHandler);
  createAcsController(true, enableHkSets);
-  satsystem::init(false);
+  satsystem::init();
 }
--- a/bsp_q7s/fs/SdCardManager.cpp
+++ b/bsp_q7s/fs/SdCardManager.cpp
@ -125,8 +125,13 @@ ReturnValue_t SdCardManager::switchOnSdCard(sd::SdCard sdCard, bool doMountSdCar
  return mountSdCard(sdCard);
 }

-ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, SdStatePair& sdStates,
-                                             bool doUnmountSdCard) {
+ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, bool doUnmountSdCard,
+                                             SdStatePair* statusPair) {
+  std::pair<sd::SdState, sd::SdState> active;
+  ReturnValue_t result = getSdCardsStatus(active);
+  if (result != returnvalue::OK) {
+    return result;
+  }
  if (doUnmountSdCard) {
    if (not blocking) {
      sif::warning << "SdCardManager::switchOffSdCard: Two-step command but manager is"
@ -142,17 +147,17 @@ ReturnValue_t SdCardManager::switchOffSdCard(sd::SdCard sdCard, SdStatePair& sdS
    return returnvalue::FAILED;
  }
  if (sdCard == sd::SdCard::SLOT_0) {
-    if (sdStates.first == sd::SdState::OFF) {
+    if (active.first == sd::SdState::OFF) {
      return ALREADY_OFF;
    }
  } else if (sdCard == sd::SdCard::SLOT_1) {
-    if (sdStates.second == sd::SdState::OFF) {
+    if (active.second == sd::SdState::OFF) {
      return ALREADY_OFF;
    }
  }

  if (doUnmountSdCard) {
-    ReturnValue_t result = unmountSdCard(sdCard);
+    result = unmountSdCard(sdCard);
    if (result != returnvalue::OK) {
      return result;
    }
@ -184,7 +189,7 @@ ReturnValue_t SdCardManager::setSdCardState(sd::SdCard sdCard, bool on) {
  command << "q7hw sd set " << sdstring << " " << statestring;
  cmdExecutor.load(command.str(), blocking, printCmdOutput);
  ReturnValue_t result = cmdExecutor.execute();
-  if (result != returnvalue::OK) {
+  if (blocking and result != returnvalue::OK) {
    utility::handleSystemError(cmdExecutor.getLastError(), "SdCardManager::setSdCardState");
  }
  return result;
@ -199,7 +204,6 @@ ReturnValue_t SdCardManager::getSdCardsStatus(SdStatePair& sdStates) {
 ReturnValue_t SdCardManager::mountSdCard(sd::SdCard sdCard) {
  using namespace std;
  if (cmdExecutor.getCurrentState() == CommandExecutor::States::PENDING) {
-    sif::warning << "SdCardManager::mountSdCard: Command still pending" << std::endl;
    return CommandExecutor::COMMAND_PENDING;
  }
  if (sdCard == sd::SdCard::BOTH) {
--- a/bsp_q7s/fs/SdCardManager.h
+++ b/bsp_q7s/fs/SdCardManager.h
@ -114,7 +114,8 @@ class SdCardManager : public SystemObject, public SdCardMountedIF {
   * @return - returnvalue::OK on success, ALREADY_ON if it is already on,
   *           SYSTEM_CALL_ERROR on system error
   */
-  ReturnValue_t switchOffSdCard(sd::SdCard sdCard, SdStatePair& sdStates, bool doUnmountSdCard);
+  ReturnValue_t switchOffSdCard(sd::SdCard sdCard, bool doUnmountSdCard = true,
+                                SdStatePair* statusPair = nullptr);

  /**
   * Get the state of the SD cards. If the state file does not exist, this function will
--- a/bsp_q7s/obsw.cpp
+++ b/bsp_q7s/obsw.cpp
@ -11,13 +11,13 @@
 #include "OBSWConfig.h"
 #include "bsp_q7s/core/WatchdogHandler.h"
 #include "commonConfig.h"
+#include "core/scheduling.h"
 #include "fsfw/tasks/TaskFactory.h"
 #include "fsfw/version.h"
 #include "mission/acs/defs.h"
 #include "mission/com/defs.h"
 #include "mission/system/systemTree.h"
 #include "q7sConfig.h"
-#include "scheduling.h"
 #include "watchdog/definitions.h"

 static constexpr int OBSW_ALREADY_RUNNING = -2;
--- a/bsp_q7s/xadc/Xadc.cpp
+++ b/bsp_q7s/xadc/Xadc.cpp
@ -129,7 +129,7 @@ ReturnValue_t Xadc::readValFromFile(const char* filename, T& val) {
    sif::warning << "Xadc::readValFromFile: Failed to open file " << filename << std::endl;
    return returnvalue::FAILED;
  }
-  char valstring[MAX_STR_LENGTH]{};
+  char valstring[MAX_STR_LENGTH] = "";
  char* returnVal = fgets(valstring, MAX_STR_LENGTH, fp);
  if (returnVal == nullptr) {
    sif::warning << "Xadc::readValFromFile: Failed to read string from file " << filename
@ -139,11 +139,6 @@ ReturnValue_t Xadc::readValFromFile(const char* filename, T& val) {
  }
  std::istringstream valSstream(valstring);
  valSstream >> val;
-  if (valSstream.bad()) {
-    sif::warning << "Xadc: Conversion of value to target type failed" << std::endl;
-    fclose(fp);
-    return returnvalue::FAILED;
-  }
  fclose(fp);
  return returnvalue::OK;
 }
--- a/common/config/devices/gpioIds.h
+++ b/common/config/devices/gpioIds.h
@ -77,8 +77,6 @@ enum gpioId_t {
  CS_RAD_SENSOR,
  ENABLE_RADFET,

-  PL_I2C_ARESETN,
-
  PAPB_BUSY_N,
  PAPB_EMPTY,

@ -95,10 +93,15 @@ enum gpioId_t {
  EN_RW_CS,

  SPI_MUX,
+
  VC0_PAPB_EMPTY,
+  VC0_PAPB_BUSY,
  VC1_PAPB_EMPTY,
+  VC1_PAPB_BUSY,
  VC2_PAPB_EMPTY,
+  VC2_PAPB_BUSY,
  VC3_PAPB_EMPTY,
+  VC3_PAPB_BUSY,
  PTME_RESETN,

  PDEC_RESET,
--- a/common/config/eive/definitions.h
+++ b/common/config/eive/definitions.h
@ -11,8 +11,6 @@ static constexpr char SD_1_MOUNT_POINT[] = "/mnt/sd1";
 static constexpr char OBSW_UPDATE_ARCHIVE_FILE_NAME[] = "eive-sw-update.tar.xz";
 static constexpr char STRIPPED_OBSW_BINARY_FILE_NAME[] = "eive-obsw-stripped";
 static constexpr char OBSW_VERSION_FILE_NAME[] = "obsw_version.txt";
-static constexpr char PUS_SEQUENCE_COUNT_FILE[] = "pus-sequence-count.txt";
-static constexpr char CFDP_SEQUENCE_COUNT_FILE[] = "cfdp-sequence-count.txt";

 static constexpr char OBSW_PATH[] = "/usr/bin/eive-obsw";
 static constexpr char OBSW_VERSION_FILE_PATH[] = "/usr/share/eive-obsw/obsw_version.txt";
--- a/dummies/CMakeLists.txt
+++ b/dummies/CMakeLists.txt
@ -19,7 +19,6 @@ target_sources(
         GpsCtrlDummy.cpp
         GyroAdisDummy.cpp
         GyroL3GD20Dummy.cpp
-         RadSensorDummy.cpp
         MgmLIS3MDLDummy.cpp
         PlPcduDummy.cpp
         ExecutableComIfDummy.cpp
--- a/dummies/CoreControllerDummy.cpp
+++ b/dummies/CoreControllerDummy.cpp
@ -1,6 +1,6 @@
 #include "CoreControllerDummy.h"

-#include <bsp_q7s/core/defs.h>
+#include <bsp_q7s/core/CoreDefinitions.h>
 #include <objects/systemObjectList.h>

 #include <cmath>
--- a/dummies/ImtqDummy.cpp
+++ b/dummies/ImtqDummy.cpp
@ -5,19 +5,14 @@
 ImtqDummy::ImtqDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie,
                     power::Switch_t pwrSwitcher, bool enableHkSets)
    : DeviceHandlerBase(objectId, comif, comCookie),
+      setNoTorque(this),
+      setWithTorque(this),
      enableHkSets(enableHkSets),
-      statusSet(this),
-      dipoleSet(*this),
-      rawMtmNoTorque(this),
-      hkDatasetNoTorque(this),
-      rawMtmWithTorque(this),
-      hkDatasetWithTorque(this),
-      calMtmMeasurementSet(this),
      switcher(pwrSwitcher) {}

 ImtqDummy::~ImtqDummy() = default;

-void ImtqDummy::doStartUp() { setMode(MODE_ON); }
+void ImtqDummy::doStartUp() { setMode(MODE_NORMAL); }

 void ImtqDummy::doShutDown() { setMode(_MODE_POWER_DOWN); }

@ -84,37 +79,17 @@ ReturnValue_t ImtqDummy::initializeLocalDataPool(localpool::DataPool &localDataP
  localDataPoolMap.emplace(imtq::MCU_TEMPERATURE_WT, new PoolEntry<int16_t>({0}));

  poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(hkDatasetNoTorque.getSid(), enableHkSets, 30.0));
+      subdp::DiagnosticsHkPeriodicParams(setNoTorque.getSid(), enableHkSets, 30.0));
  poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(hkDatasetWithTorque.getSid(), enableHkSets, 30.0));
-  poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(rawMtmNoTorque.getSid(), false, 10.0));
-  poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(rawMtmWithTorque.getSid(), false, 10.0));
-  poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(calMtmMeasurementSet.getSid(), false, 10.0));
-  poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(statusSet.getSid(), false, 10.0));
-  poolManager.subscribeForDiagPeriodicPacket(
-      subdp::DiagnosticsHkPeriodicParams(dipoleSet.getSid(), false, 10.0));
+      subdp::DiagnosticsHkPeriodicParams(setWithTorque.getSid(), enableHkSets, 30.0));
  return DeviceHandlerBase::initializeLocalDataPool(localDataPoolMap, poolManager);
 }

 LocalPoolDataSetBase *ImtqDummy::getDataSetHandle(sid_t sid) {
-  if (sid == hkDatasetNoTorque.getSid()) {
-    return &hkDatasetNoTorque;
-  } else if (sid == dipoleSet.getSid()) {
-    return &dipoleSet;
-  } else if (sid == statusSet.getSid()) {
-    return &statusSet;
-  } else if (sid == hkDatasetWithTorque.getSid()) {
-    return &hkDatasetWithTorque;
-  } else if (sid == rawMtmWithTorque.getSid()) {
-    return &rawMtmWithTorque;
-  } else if (sid == calMtmMeasurementSet.getSid()) {
-    return &calMtmMeasurementSet;
-  } else if (sid == rawMtmNoTorque.getSid()) {
-    return &rawMtmNoTorque;
+  if (sid == setNoTorque.getSid()) {
+    return &setNoTorque;
+  } else if (sid == setWithTorque.getSid()) {
+    return &setWithTorque;
  }
  return nullptr;
 }
--- a/dummies/ImtqDummy.h
+++ b/dummies/ImtqDummy.h
@ -18,18 +18,11 @@ class ImtqDummy : public DeviceHandlerBase {
  ~ImtqDummy() override;

 protected:
+  ReturnValue_t getSwitches(const uint8_t **switches, uint8_t *numberOfSwitches) override;
+  imtq::HkDatasetNoTorque setNoTorque;
+  imtq::HkDatasetWithTorque setWithTorque;
  bool enableHkSets;

-  imtq::StatusDataset statusSet;
-  imtq::DipoleActuationSet dipoleSet;
-  imtq::RawMtmMeasurementNoTorque rawMtmNoTorque;
-  imtq::HkDatasetNoTorque hkDatasetNoTorque;
-
-  imtq::RawMtmMeasurementWithTorque rawMtmWithTorque;
-  imtq::HkDatasetWithTorque hkDatasetWithTorque;
-
-  imtq::CalibratedMtmMeasurementSet calMtmMeasurementSet;
-
  PoolEntry<uint8_t> statusMode = PoolEntry<uint8_t>({0});
  PoolEntry<uint8_t> statusError = PoolEntry<uint8_t>({0});
  PoolEntry<uint8_t> statusConfig = PoolEntry<uint8_t>({0});
@ -49,8 +42,6 @@ class ImtqDummy : public DeviceHandlerBase {

  power::Switch_t switcher = power::NO_SWITCH;

-  ReturnValue_t getSwitches(const uint8_t **switches, uint8_t *numberOfSwitches) override;
-
  void doStartUp() override;
  void doShutDown() override;
  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
--- a/dummies/Max31865Dummy.cpp
+++ b/dummies/Max31865Dummy.cpp
@ -7,21 +7,15 @@ using namespace returnvalue;
 Max31865Dummy::Max31865Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
    : DeviceHandlerBase(objectId, comif, comCookie), set(this, EiveMax31855::EXCHANGE_SET_ID) {}
 void Max31865Dummy::doStartUp() { setMode(MODE_ON); }
-void Max31865Dummy::doShutDown() {
-  PoolReadGuard pg(&set);
-  set.setValidity(false, true);
-  setMode(MODE_OFF);
-}
+void Max31865Dummy::doShutDown() { setMode(_MODE_POWER_DOWN); }
 ReturnValue_t Max31865Dummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
  return NOTHING_TO_SEND;
 }
-ReturnValue_t Max31865Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
-  return NOTHING_TO_SEND;
-}
+ReturnValue_t Max31865Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) { return OK; }
 ReturnValue_t Max31865Dummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                     const uint8_t *commandData,
                                                     size_t commandDataLen) {
-  return NOTHING_TO_SEND;
+  return 0;
 }
 ReturnValue_t Max31865Dummy::scanForReply(const uint8_t *start, size_t len,
                                          DeviceCommandId_t *foundId, size_t *foundLen) {
--- a/dummies/PlPcduDummy.cpp
+++ b/dummies/PlPcduDummy.cpp
@ -7,7 +7,7 @@ PlPcduDummy::PlPcduDummy(object_id_t objectId, object_id_t comif, CookieIF *comC

 PlPcduDummy::~PlPcduDummy() {}

-void PlPcduDummy::doStartUp() { setMode(MODE_ON); }
+void PlPcduDummy::doStartUp() { setMode(MODE_NORMAL); }

 void PlPcduDummy::doShutDown() { setMode(MODE_OFF); }

--- a/dummies/RadSensorDummy.cpp
+++ b/dummies/RadSensorDummy.cpp
@ -1,55 +0,0 @@
-#include "RadSensorDummy.h"
-
-RadSensorDummy::RadSensorDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
-    : DeviceHandlerBase(objectId, comif, comCookie), sensorSet(this) {}
-
-RadSensorDummy::~RadSensorDummy() {}
-
-void RadSensorDummy::doStartUp() { setMode(MODE_ON); }
-
-void RadSensorDummy::doShutDown() { setMode(MODE_OFF); }
-
-ReturnValue_t RadSensorDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
-  return NOTHING_TO_SEND;
-}
-
-ReturnValue_t RadSensorDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
-  return NOTHING_TO_SEND;
-}
-
-ReturnValue_t RadSensorDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                      const uint8_t *commandData,
-                                                      size_t commandDataLen) {
-  return returnvalue::OK;
-}
-
-ReturnValue_t RadSensorDummy::scanForReply(const uint8_t *start, size_t len,
-                                           DeviceCommandId_t *foundId, size_t *foundLen) {
-  return returnvalue::OK;
-}
-
-ReturnValue_t RadSensorDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  return returnvalue::OK;
-}
-
-void RadSensorDummy::fillCommandAndReplyMap() {}
-
-uint32_t RadSensorDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
-
-ReturnValue_t RadSensorDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                                      LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(radSens::TEMPERATURE_C, new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(radSens::AIN0, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(radSens::AIN1, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(radSens::AIN4, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(radSens::AIN5, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(radSens::AIN6, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(radSens::AIN7, new PoolEntry<uint16_t>({0}));
-  poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(sensorSet.getSid(), false, 20.0));
-  return returnvalue::OK;
-
-  return returnvalue::OK;
-}
-
-LocalPoolDataSetBase *RadSensorDummy::getDataSetHandle(sid_t sid) { return &sensorSet; }
--- a/dummies/RadSensorDummy.h
+++ b/dummies/RadSensorDummy.h
@ -1,35 +0,0 @@
-#pragma once
-
-#include <fsfw/devicehandlers/DeviceHandlerBase.h>
-
-#include "mission/payload/radSensorDefinitions.h"
-
-class RadSensorDummy : public DeviceHandlerBase {
- public:
-  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
-  static const DeviceCommandId_t PERIODIC_REPLY = 2;
-
-  static const uint8_t SIMPLE_COMMAND_DATA = 1;
-  static const uint8_t PERIODIC_REPLY_DATA = 2;
-
-  RadSensorDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
-  virtual ~RadSensorDummy();
-
- protected:
-  radSens::RadSensorDataset sensorSet;
-
-  void doStartUp() override;
-  void doShutDown() override;
-  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
-  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
-  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
-                                        size_t commandDataLen) override;
-  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
-                             size_t *foundLen) override;
-  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
-  void fillCommandAndReplyMap() override;
-  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;
-};
--- a/dummies/RwDummy.cpp
+++ b/dummies/RwDummy.cpp
@ -3,24 +3,13 @@
 #include <mission/acs/rwHelpers.h>

 RwDummy::RwDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
-    : DeviceHandlerBase(objectId, comif, comCookie),
-
-      statusSet(this),
-      lastResetStatusSet(this),
-      tmDataset(this),
-      rwSpeedActuationSet(*this) {}
+    : DeviceHandlerBase(objectId, comif, comCookie) {}

 RwDummy::~RwDummy() {}

-void RwDummy::doStartUp() {
-  statusSet.setReportingEnabled(true);
-  setMode(MODE_ON);
-}
+void RwDummy::doStartUp() { setMode(MODE_ON); }

-void RwDummy::doShutDown() {
-  statusSet.setReportingEnabled(false);
-  setMode(MODE_OFF);
-}
+void RwDummy::doShutDown() { setMode(MODE_OFF); }

 ReturnValue_t RwDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }

@ -85,11 +74,5 @@ ReturnValue_t RwDummy::initializeLocalDataPool(localpool::DataPool &localDataPoo
  localDataPoolMap.emplace(rws::SPI_BYTES_READ, new PoolEntry<uint32_t>({0}));
  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, 12.0));
-  poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(tmDataset.getSid(), false, 30.0));
-  poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(lastResetStatusSet.getSid(), false, 30.0));
  return returnvalue::OK;
 }
--- a/dummies/RwDummy.h
+++ b/dummies/RwDummy.h
@ -2,7 +2,6 @@
 #define DUMMIES_RWDUMMY_H_

 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
-#include <mission/acs/rwHelpers.h>

 class RwDummy : public DeviceHandlerBase {
 public:
@ -16,11 +15,6 @@ class RwDummy : public DeviceHandlerBase {
  virtual ~RwDummy();

 protected:
-  rws::StatusSet statusSet;
-  rws::LastResetSatus lastResetStatusSet;
-  rws::TmDataset tmDataset;
-  rws::RwSpeedActuationSet rwSpeedActuationSet;
-
  PoolEntry<int32_t> rwSpeed = PoolEntry<int32_t>({0});
  PoolEntry<uint16_t> rampTime = PoolEntry<uint16_t>({10});

--- a/dummies/SusDummy.cpp
+++ b/dummies/SusDummy.cpp
@ -5,7 +5,7 @@ SusDummy::SusDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)

 SusDummy::~SusDummy() {}

-void SusDummy::doStartUp() { setMode(MODE_ON); }
+void SusDummy::doStartUp() { setMode(MODE_NORMAL); }

 void SusDummy::doShutDown() { setMode(MODE_OFF); }

--- a/dummies/TemperatureSensorInserter.cpp
+++ b/dummies/TemperatureSensorInserter.cpp
@ -7,9 +7,9 @@
 #include <cstdlib>
 #include <utility>

-TemperatureSensorInserter::TemperatureSensorInserter(
-    object_id_t objectId, Max31865DummyMap tempSensorDummies_,
-    std::optional<Tmp1075DummyMap> tempTmpSensorDummies_)
+TemperatureSensorInserter::TemperatureSensorInserter(object_id_t objectId,
+                                                     Max31865DummyMap tempSensorDummies_,
+                                                     Tmp1075DummyMap tempTmpSensorDummies_)
    : SystemObject(objectId),
      max31865DummyMap(std::move(tempSensorDummies_)),
      tmp1075DummyMap(std::move(tempTmpSensorDummies_)) {}
@ -25,10 +25,8 @@ ReturnValue_t TemperatureSensorInserter::performOperation(uint8_t opCode) {
    for (auto& rtdDummy : max31865DummyMap) {
      rtdDummy.second->setTemperature(10, true);
    }
-    if (tmp1075DummyMap.has_value()) {
-      for (auto& tmpDummy : tmp1075DummyMap.value()) {
-        tmpDummy.second->setTemperature(10, true);
-      }
+    for (auto& tmpDummy : tmp1075DummyMap) {
+      tmpDummy.second->setTemperature(10, true);
    }
    tempsWereInitialized = true;
  }
@ -98,25 +96,6 @@ ReturnValue_t TemperatureSensorInserter::performOperation(uint8_t opCode) {
      }
      break;
    }
-    case (TestCase::COLD_PLOC_CONSECUTIVE): {
-      if (cycles == 15) {
-        sif::debug << "Setting cold PLOC temperature" << std::endl;
-        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(-15, true);
-      }
-      if (cycles == 30) {
-        sif::debug << "Setting warmer PLOC temperature" << std::endl;
-        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(0, true);
-      }
-      if (cycles == 45) {
-        sif::debug << "Setting cold PLOC temperature again" << std::endl;
-        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(-15, true);
-      }
-      if (cycles == 60) {
-        sif::debug << "Setting warmer PLOC temperature again" << std::endl;
-        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(0, true);
-      }
-      break;
-    }
    case (TestCase::COLD_CAMERA): {
      if (cycles == 15) {
        sif::debug << "Setting cold CAM temperature" << std::endl;
@ -126,21 +105,6 @@ ReturnValue_t TemperatureSensorInserter::performOperation(uint8_t opCode) {
        sif::debug << "Setting CAM temperature back to normal" << std::endl;
        max31865DummyMap[objects::RTD_2_IC5_4K_CAMERA]->setTemperature(0, true);
      }
-      break;
-    }
-    case (TestCase::COLD_PLOC_STAYS_COLD): {
-      if (cycles == 15) {
-        sif::debug << "Setting cold PLOC temperature" << std::endl;
-        max31865DummyMap[objects::RTD_0_IC3_PLOC_HEATSPREADER]->setTemperature(-40, true);
-      }
-      break;
-    }
-    case (TestCase::COLD_CAMERA_STAYS_COLD): {
-      if (cycles == 15) {
-        sif::debug << "Setting cold PLOC temperature" << std::endl;
-        max31865DummyMap[objects::RTD_2_IC5_4K_CAMERA]->setTemperature(-40, true);
-      }
-      break;
    }
  }
  cycles++;
--- a/dummies/TemperatureSensorInserter.h
+++ b/dummies/TemperatureSensorInserter.h
@ -12,7 +12,7 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject
  using Max31865DummyMap = std::map<object_id_t, Max31865Dummy*>;
  using Tmp1075DummyMap = std::map<object_id_t, Tmp1075Dummy*>;
  explicit TemperatureSensorInserter(object_id_t objectId, Max31865DummyMap tempSensorDummies_,
-                                     std::optional<Tmp1075DummyMap> tempTmpSensorDummies_);
+                                     Tmp1075DummyMap tempTmpSensorDummies_);

  ReturnValue_t initialize() override;
  ReturnValue_t initializeAfterTaskCreation() override;
@ -22,7 +22,7 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject

 private:
  Max31865DummyMap max31865DummyMap;
-  std::optional<Tmp1075DummyMap> tmp1075DummyMap;
+  Tmp1075DummyMap tmp1075DummyMap;

  enum TestCase {
    NONE = 0,
@ -32,9 +32,6 @@ class TemperatureSensorInserter : public ExecutableObjectIF, public SystemObject
    COLD_STR = 4,
    COLD_STR_CONSECUTIVE = 5,
    COLD_CAMERA = 6,
-    COLD_PLOC_CONSECUTIVE = 7,
-    COLD_PLOC_STAYS_COLD = 8,
-    COLD_CAMERA_STAYS_COLD = 9
  };
  int iteration = 0;
  uint32_t cycles = 0;
--- a/dummies/Tmp1075Dummy.cpp
+++ b/dummies/Tmp1075Dummy.cpp
@ -8,57 +8,35 @@ using namespace returnvalue;
 Tmp1075Dummy::Tmp1075Dummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
    : DeviceHandlerBase(objectId, comif, comCookie), set(this) {}

-void Tmp1075Dummy::doStartUp() { setMode(MODE_ON); }
-void Tmp1075Dummy::doShutDown() {
-  PoolReadGuard pg(&set);
-  set.setValidity(false, true);
-  setMode(MODE_OFF);
-}
+void Tmp1075Dummy::doStartUp() { setMode(MODE_NORMAL); }
+void Tmp1075Dummy::doShutDown() { setMode(MODE_OFF); }

 ReturnValue_t Tmp1075Dummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
  return NOTHING_TO_SEND;
 }
-
-ReturnValue_t Tmp1075Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
-  return NOTHING_TO_SEND;
-}
-
+ReturnValue_t Tmp1075Dummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) { return OK; }
 ReturnValue_t Tmp1075Dummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                    const uint8_t *commandData,
                                                    size_t commandDataLen) {
-  return NOTHING_TO_SEND;
+  return 0;
 }
-
 ReturnValue_t Tmp1075Dummy::scanForReply(const uint8_t *start, size_t len,
                                         DeviceCommandId_t *foundId, size_t *foundLen) {
  return 0;
 }
-
 ReturnValue_t Tmp1075Dummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
  return 0;
 }
-
 void Tmp1075Dummy::setTemperature(float temperature, bool valid) {
  PoolReadGuard pg(&set);
  set.temperatureCelcius.value = temperature;
  set.setValidity(valid, true);
 }
-
 void Tmp1075Dummy::fillCommandAndReplyMap() {}
-
 uint32_t Tmp1075Dummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 1000; }
-
 ReturnValue_t Tmp1075Dummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                    LocalDataPoolManager &poolManager) {
  localDataPoolMap.emplace(TMP1075::TEMPERATURE_C_TMP1075, new PoolEntry<float>({10.0}, true));
  return OK;
 }
-
-ReturnValue_t Tmp1075Dummy::setHealth(HealthState health) {
-  if (health == FAULTY or health == PERMANENT_FAULTY) {
-    setMode(_MODE_SHUT_DOWN);
-  }
-  return DeviceHandlerBase::setHealth(health);
-}
-
 LocalPoolDataSetBase *Tmp1075Dummy::getDataSetHandle(sid_t sid) { return &set; }
--- a/dummies/Tmp1075Dummy.h
+++ b/dummies/Tmp1075Dummy.h
@ -26,7 +26,6 @@ class Tmp1075Dummy : public DeviceHandlerBase {
  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                        LocalDataPoolManager &poolManager) override;
-  ReturnValue_t setHealth(HealthState health) override;

 protected:
  LocalPoolDataSetBase *getDataSetHandle(sid_t sid) override;
--- a/dummies/helperFactory.cpp
+++ b/dummies/helperFactory.cpp
@ -18,7 +18,6 @@
 #include <dummies/PlPcduDummy.h>
 #include <dummies/PlocMpsocDummy.h>
 #include <dummies/PlocSupervisorDummy.h>
-#include <dummies/RadSensorDummy.h>
 #include <dummies/RwDummy.h>
 #include <dummies/SaDeploymentDummy.h>
 #include <dummies/ScexDummy.h>
@ -35,7 +34,6 @@

 #include "TemperatureSensorInserter.h"
 #include "dummies/Max31865Dummy.h"
-#include "dummies/SusDummy.h"
 #include "dummies/Tmp1075Dummy.h"
 #include "mission/genericFactory.h"
 #include "mission/system/acs/acsModeTree.h"
@ -65,14 +63,11 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
  rws[3] = new RwDummy(objects::RW4, objects::DUMMY_COM_IF, comCookieDummy);
  ObjectFactory::createRwAssy(pwrSwitcher, power::Switches::PDU2_CH2_RW_5V, rws, rwIds);
  new SaDeplDummy(objects::SOLAR_ARRAY_DEPL_HANDLER);
-
-  if (cfg.addStrDummy) {
-    auto* strAssy = new StrAssembly(objects::STR_ASSY);
-    strAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
-    auto* strDummy =
-        new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
-    strDummy->connectModeTreeParent(*strAssy);
-  }
+  auto* strAssy = new StrAssembly(objects::STR_ASSY);
+  strAssy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
+  auto* strDummy =
+      new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
+  strDummy->connectModeTreeParent(*strAssy);
  if (cfg.addSyrlinksDummies) {
    auto* syrlinksDummy =
        new SyrlinksDummy(objects::SYRLINKS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
@ -196,36 +191,25 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
        objects::RTD_15_IC18_IMTQ,
        new Max31865Dummy(objects::RTD_15_IC18_IMTQ, objects::DUMMY_COM_IF, comCookieDummy));

-    std::optional<TemperatureSensorInserter::Tmp1075DummyMap> tmpSensorDummies;
-    if (cfg.addTmpDummies) {
-      TemperatureSensorInserter::Tmp1075DummyMap tmpDummyMap;
-      if (cfg.tmp1075Cfg.addTcsBrd0) {
-        tmpDummyMap.emplace(objects::TMP1075_HANDLER_TCS_0,
-                            new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_0, objects::DUMMY_COM_IF,
-                                             comCookieDummy));
-      }
-      if (cfg.tmp1075Cfg.addTcsBrd1) {
-        tmpDummyMap.emplace(objects::TMP1075_HANDLER_TCS_1,
-                            new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_1, objects::DUMMY_COM_IF,
-                                             comCookieDummy));
-      }
-      if (cfg.tmp1075Cfg.addPlPcdu0) {
-        tmpDummyMap.emplace(objects::TMP1075_HANDLER_PLPCDU_0,
-                            new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_0,
-                                             objects::DUMMY_COM_IF, comCookieDummy));
-      }
-      if (cfg.tmp1075Cfg.addPlPcdu1) {
-        tmpDummyMap.emplace(objects::TMP1075_HANDLER_PLPCDU_1,
-                            new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_1,
-                                             objects::DUMMY_COM_IF, comCookieDummy));
-      }
-      if (cfg.tmp1075Cfg.addIfBrd) {
-        tmpDummyMap.emplace(objects::TMP1075_HANDLER_IF_BOARD,
-                            new Tmp1075Dummy(objects::TMP1075_HANDLER_IF_BOARD,
-                                             objects::DUMMY_COM_IF, comCookieDummy));
-      }
-      tmpSensorDummies = std::move(tmpDummyMap);
-    }
+    std::map<object_id_t, Tmp1075Dummy*> tmpSensorDummies;
+    tmpSensorDummies.emplace(
+        objects::TMP1075_HANDLER_TCS_0,
+        new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_0, objects::DUMMY_COM_IF, comCookieDummy));
+    tmpSensorDummies.emplace(
+        objects::TMP1075_HANDLER_TCS_1,
+        new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_1, objects::DUMMY_COM_IF, comCookieDummy));
+    tmpSensorDummies.emplace(
+        objects::TMP1075_HANDLER_PLPCDU_0,
+        new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_0, objects::DUMMY_COM_IF, comCookieDummy));
+    // damaged.
+    //        tmpSensorDummies.emplace(
+    //            objects::TMP1075_HANDLER_PLPCDU_1,
+    //            new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_1, objects::DUMMY_COM_IF,
+    //            comCookieDummy));
+    tmpSensorDummies.emplace(
+        objects::TMP1075_HANDLER_IF_BOARD,
+        new Tmp1075Dummy(objects::TMP1075_HANDLER_IF_BOARD, objects::DUMMY_COM_IF, comCookieDummy));
+
    new TemperatureSensorInserter(objects::THERMAL_TEMP_INSERTER, rtdSensorDummies,
                                  tmpSensorDummies);
    TcsBoardAssembly* tcsBoardAssy =
@ -233,10 +217,8 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
    for (auto& rtd : rtdSensorDummies) {
      rtd.second->connectModeTreeParent(*tcsBoardAssy);
    }
-    if (tmpSensorDummies.has_value()) {
-      for (auto& tmp : tmpSensorDummies.value()) {
-        tmp.second->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
-      }
+    for (auto& tmp : tmpSensorDummies) {
+      tmp.second->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
    }
  }
  if (cfg.addCamSwitcherDummy) {
@ -244,10 +226,8 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
                                        power::Switches::PDU2_CH8_PAYLOAD_CAMERA);
    camSwitcher->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
  }
-  if (cfg.addScexDummy) {
-    auto* scexDummy = new ScexDummy(objects::SCEX, objects::DUMMY_COM_IF, comCookieDummy);
-    scexDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
-  }
+  auto* scexDummy = new ScexDummy(objects::SCEX, objects::DUMMY_COM_IF, comCookieDummy);
+  scexDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
  auto* plPcduDummy =
      new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
  plPcduDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
@ -259,9 +239,4 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
        objects::PLOC_SUPERVISOR_HANDLER, objects::DUMMY_COM_IF, comCookieDummy, pwrSwitcher);
    plocSupervisorDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
  }
-  if (cfg.addRadSensorDummy) {
-    auto* radSensorDummy =
-        new RadSensorDummy(objects::RAD_SENSOR, objects::DUMMY_COM_IF, comCookieDummy);
-    radSensorDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
-  }
 }
--- a/dummies/helperFactory.h
+++ b/dummies/helperFactory.h
@ -6,14 +6,6 @@ class GpioIF;

 namespace dummy {

-struct Tmp1075Cfg {
-  bool addTcsBrd0 = true;
-  bool addTcsBrd1 = true;
-  bool addPlPcdu0 = true;
-  bool addPlPcdu1 = true;
-  bool addIfBrd = true;
-};
-
 // Default values targeted towards EM.
 struct DummyCfg {
  bool addCoreCtrlCfg = true;
@ -27,12 +19,7 @@ struct DummyCfg {
  bool addTempSensorDummies = true;
  bool addRtdComIFDummy = true;
  bool addPlocDummies = true;
-  bool addStrDummy = true;
-  bool addTmpDummies = true;
-  bool addRadSensorDummy = true;
-  Tmp1075Cfg tmp1075Cfg;
  bool addCamSwitcherDummy = false;
-  bool addScexDummy = false;
 };

 void createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch, GpioIF* gpioIF, bool enableHkSets);
--- a/2
+++ b/2
--- a/generators/bsp_hosted_events.csv
+++ b/generators/bsp_hosted_events.csv
@ -133,7 +133,6 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11802;0x2e1a;RESET_OCCURED;LOW;No description;mission/acs/rwHelpers.h
 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/PlocSupervisorHandler.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/PlocSupervisorHandler.h
@ -272,8 +271,6 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14010;0x36ba;TRYING_I2C_RECOVERY;HIGH;I2C is unavailable. Trying recovery of I2C bus by power cycling all I2C devices.;mission/sysDefs.h
 14011;0x36bb;I2C_REBOOT;HIGH;I2C is unavailable. Recovery did not work, performing full reboot.;mission/sysDefs.h
 14012;0x36bc;PDEC_REBOOT;HIGH;PDEC recovery through reset was not possible, performing full reboot.;mission/sysDefs.h
-14013;0x36bd;FIRMWARE_INFO;INFO;Version information of the firmware (not OBSW). P1: Byte 0: Major, Byte 1: Minor, Byte 2: Patch, Byte 3: Has Git Hash P2: First four letters of Git SHA is the last byte of P1 is set.;mission/sysDefs.h
-14014;0x36be;ACTIVE_SD_INFO;INFO;Active SD card info. SD States: 0: OFF, 1: ON, 2: MOUNTED. P1: Active SD Card Index, 0 if none is active P2: First two bytes: SD state of SD card 0, last two bytes SD state of SD card 1;mission/sysDefs.h
 14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/tcsDefs.h
 14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/tcsDefs.h
 14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
@ -282,9 +279,6 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14106;0x371a;PCDU_SYSTEM_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
 14107;0x371b;HEATER_NOT_OFF_FOR_OFF_MODE;MEDIUM;No description;mission/controller/tcsDefs.h
 14108;0x371c;MGT_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
-14109;0x371d;TCS_SWITCHING_HEATER_ON;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
-14110;0x371e;TCS_SWITCHING_HEATER_OFF;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
-14111;0x371f;TCS_HEATER_MAX_BURN_TIME_REACHED;MEDIUM;P1: Heater index. P2: Maximum burn time for heater.;mission/controller/tcsDefs.h
 14201;0x3779;TX_TIMER_EXPIRED;INFO;The transmit timer to protect the Syrlinks expired P1: The current timer value;mission/system/com/ComSubsystem.h
 14202;0x377a;BIT_LOCK_TX_ON;INFO;Transmitter will be turned on due to detection of bitlock;mission/system/com/ComSubsystem.h
 14300;0x37dc;POSSIBLE_FILE_CORRUPTION;LOW;P1: Result code of TM packet parser. P2: Timestamp of possibly corrupt file as a unix timestamp.;mission/persistentTmStoreDefs.h
--- a/generators/bsp_q7s_events.csv
+++ b/generators/bsp_q7s_events.csv
@ -133,7 +133,6 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 11802;0x2e1a;RESET_OCCURED;LOW;No description;mission/acs/rwHelpers.h
 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/PlocSupervisorHandler.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/PlocSupervisorHandler.h
@ -272,8 +271,6 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14010;0x36ba;TRYING_I2C_RECOVERY;HIGH;I2C is unavailable. Trying recovery of I2C bus by power cycling all I2C devices.;mission/sysDefs.h
 14011;0x36bb;I2C_REBOOT;HIGH;I2C is unavailable. Recovery did not work, performing full reboot.;mission/sysDefs.h
 14012;0x36bc;PDEC_REBOOT;HIGH;PDEC recovery through reset was not possible, performing full reboot.;mission/sysDefs.h
-14013;0x36bd;FIRMWARE_INFO;INFO;Version information of the firmware (not OBSW). P1: Byte 0: Major, Byte 1: Minor, Byte 2: Patch, Byte 3: Has Git Hash P2: First four letters of Git SHA is the last byte of P1 is set.;mission/sysDefs.h
-14014;0x36be;ACTIVE_SD_INFO;INFO;Active SD card info. SD States: 0: OFF, 1: ON, 2: MOUNTED. P1: Active SD Card Index, 0 if none is active P2: First two bytes: SD state of SD card 0, last two bytes SD state of SD card 1;mission/sysDefs.h
 14100;0x3714;NO_VALID_SENSOR_TEMPERATURE;MEDIUM;No description;mission/controller/tcsDefs.h
 14101;0x3715;NO_HEALTHY_HEATER_AVAILABLE;MEDIUM;No description;mission/controller/tcsDefs.h
 14102;0x3716;SYRLINKS_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
@ -282,9 +279,6 @@ Event ID (dec); Event ID (hex); Name; Severity; Description; File Path
 14106;0x371a;PCDU_SYSTEM_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
 14107;0x371b;HEATER_NOT_OFF_FOR_OFF_MODE;MEDIUM;No description;mission/controller/tcsDefs.h
 14108;0x371c;MGT_OVERHEATING;HIGH;No description;mission/controller/tcsDefs.h
-14109;0x371d;TCS_SWITCHING_HEATER_ON;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
-14110;0x371e;TCS_SWITCHING_HEATER_OFF;INFO;P1: Module index. P2: Heater index;mission/controller/tcsDefs.h
-14111;0x371f;TCS_HEATER_MAX_BURN_TIME_REACHED;MEDIUM;P1: Heater index. P2: Maximum burn time for heater.;mission/controller/tcsDefs.h
 14201;0x3779;TX_TIMER_EXPIRED;INFO;The transmit timer to protect the Syrlinks expired P1: The current timer value;mission/system/com/ComSubsystem.h
 14202;0x377a;BIT_LOCK_TX_ON;INFO;Transmitter will be turned on due to detection of bitlock;mission/system/com/ComSubsystem.h
 14300;0x37dc;POSSIBLE_FILE_CORRUPTION;LOW;P1: Result code of TM packet parser. P2: Timestamp of possibly corrupt file as a unix timestamp.;mission/persistentTmStoreDefs.h
--- a/generators/events/event_parser.py
+++ b/generators/events/event_parser.py
@ -54,13 +54,9 @@ class BspConfig:

        # Store this file in the root of the generators folder
        self.csv_filename = Path(f"{ROOT_DIR}/{self.bsp_dir_name}_events.csv")
-        self.subsystems_csv_filename = Path(
-            f"{ROOT_DIR}/{self.bsp_dir_name}_subsystems.csv"
-        )
+        self.subsystems_csv_filename = Path(f"{ROOT_DIR}/{self.bsp_dir_name}_subsystems.csv")
        self.csv_copy_dest = Path(f"{OBSW_ROOT_DIR}/tmtc/eive_tmtc/config/events.csv")
-        self.subsystem_csv_copy_dest = Path(
-            f"{OBSW_ROOT_DIR}/tmtc/eive_tmtc/config/subsystems.csv"
-        )
+        self.subsystem_csv_copy_dest = Path(f"{OBSW_ROOT_DIR}/tmtc/eive_tmtc/config/subsystems.csv")

        if (
            self.bsp_select == BspType.BSP_Q7S
--- a/generators/events/translateEvents.cpp
+++ b/generators/events/translateEvents.cpp
@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 301 translations.
+ * @brief    Auto-generated event translation file. Contains 295 translations.
 * @details
- * Generated on: 2023-07-26 12:51:20
+ * Generated on: 2023-05-17 17:15:34
 */
 #include "translateEvents.h"

@ -139,7 +139,6 @@ const char *ERROR_STATE_STRING = "ERROR_STATE";
 const char *RESET_OCCURED_STRING = "RESET_OCCURED";
 const char *BOOTING_FIRMWARE_FAILED_EVENT_STRING = "BOOTING_FIRMWARE_FAILED_EVENT";
 const char *BOOTING_BOOTLOADER_FAILED_EVENT_STRING = "BOOTING_BOOTLOADER_FAILED_EVENT";
-const char *COM_ERROR_REPLY_RECEIVED_STRING = "COM_ERROR_REPLY_RECEIVED";
 const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
 const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
 const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
@ -278,8 +277,6 @@ const char *INDIVIDUAL_BOOT_COUNTS_STRING = "INDIVIDUAL_BOOT_COUNTS";
 const char *TRYING_I2C_RECOVERY_STRING = "TRYING_I2C_RECOVERY";
 const char *I2C_REBOOT_STRING = "I2C_REBOOT";
 const char *PDEC_REBOOT_STRING = "PDEC_REBOOT";
-const char *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
-const char *ACTIVE_SD_INFO_STRING = "ACTIVE_SD_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@ -288,9 +285,6 @@ const char *CAMERA_OVERHEATING_STRING = "CAMERA_OVERHEATING";
 const char *PCDU_SYSTEM_OVERHEATING_STRING = "PCDU_SYSTEM_OVERHEATING";
 const char *HEATER_NOT_OFF_FOR_OFF_MODE_STRING = "HEATER_NOT_OFF_FOR_OFF_MODE";
 const char *MGT_OVERHEATING_STRING = "MGT_OVERHEATING";
-const char *TCS_SWITCHING_HEATER_ON_STRING = "TCS_SWITCHING_HEATER_ON";
-const char *TCS_SWITCHING_HEATER_OFF_STRING = "TCS_SWITCHING_HEATER_OFF";
-const char *TCS_HEATER_MAX_BURN_TIME_REACHED_STRING = "TCS_HEATER_MAX_BURN_TIME_REACHED";
 const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
 const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
 const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
@ -577,8 +571,6 @@ const char *translateEvents(Event event) {
      return BOOTING_FIRMWARE_FAILED_EVENT_STRING;
    case (11902):
      return BOOTING_BOOTLOADER_FAILED_EVENT_STRING;
-    case (11903):
-      return COM_ERROR_REPLY_RECEIVED_STRING;
    case (12001):
      return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
    case (12002):
@ -855,10 +847,6 @@ const char *translateEvents(Event event) {
      return I2C_REBOOT_STRING;
    case (14012):
      return PDEC_REBOOT_STRING;
-    case (14013):
-      return FIRMWARE_INFO_STRING;
-    case (14014):
-      return ACTIVE_SD_INFO_STRING;
    case (14100):
      return NO_VALID_SENSOR_TEMPERATURE_STRING;
    case (14101):
@ -875,12 +863,6 @@ const char *translateEvents(Event event) {
      return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
    case (14108):
      return MGT_OVERHEATING_STRING;
-    case (14109):
-      return TCS_SWITCHING_HEATER_ON_STRING;
-    case (14110):
-      return TCS_SWITCHING_HEATER_OFF_STRING;
-    case (14111):
-      return TCS_HEATER_MAX_BURN_TIME_REACHED_STRING;
    case (14201):
      return TX_TIMER_EXPIRED_STRING;
    case (14202):
--- a/generators/objects/translateObjects.cpp
+++ b/generators/objects/translateObjects.cpp
@ -2,7 +2,7 @@
 * @brief  Auto-generated object translation file.
 * @details
 * Contains 175 translations.
- * Generated on: 2023-07-26 12:51:20
+ * Generated on: 2023-05-17 17:15:34
 */
 #include "translateObjects.h"

--- a/linux/acs/StrComHandler.cpp
+++ b/linux/acs/StrComHandler.cpp
@ -2,7 +2,6 @@

 #include <fcntl.h>
 #include <fsfw/filesystem/HasFileSystemIF.h>
-#include <fsfw/globalfunctions/arrayprinter.h>
 #include <fsfw/tasks/TaskFactory.h>
 #include <fsfw/timemanager/Stopwatch.h>
 #include <mission/acs/str/strHelpers.h>
@ -24,8 +23,6 @@ extern "C" {

 using namespace returnvalue;

-static constexpr bool PACKET_WIRETAPPING = false;
-
 StrComHandler::StrComHandler(object_id_t objectId) : SystemObject(objectId) {
  lock = MutexFactory::instance()->createMutex();
  semaphore.acquire();
@ -55,7 +52,7 @@ ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
      case InternalState::POLL_ONE_REPLY: {
        // Stopwatch watch;
        replyTimeout.setTimeout(200);
-        readOneReply(static_cast<uint32_t>(state));
+        replyResult = readOneReply(static_cast<uint32_t>(state));
        {
          MutexGuard mg(lock);
          replyWasReceived = true;
@ -683,10 +680,6 @@ ReturnValue_t StrComHandler::sendMessage(CookieIF* cookie, const uint8_t* sendDa
  const uint8_t* txFrame;
  size_t frameLen;
  datalinkLayer.encodeFrame(sendData, sendLen, &txFrame, frameLen);
-  if (PACKET_WIRETAPPING) {
-    sif::debug << "Sending STR frame" << std::endl;
-    arrayprinter::print(txFrame, frameLen);
-  }
  ssize_t bytesWritten = write(serialPort, txFrame, frameLen);
  if (bytesWritten != static_cast<ssize_t>(frameLen)) {
    sif::warning << "StrComHandler: Sending packet failed" << std::endl;
@ -716,11 +709,13 @@ ReturnValue_t StrComHandler::requestReceiveMessage(CookieIF* cookie, size_t requ
 }

 ReturnValue_t StrComHandler::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
+  // Consider it a configuration error if the task is not done with a command -> reply cycle
+  // in time.
  bool replyWasReceived = false;
  {
    MutexGuard mg(lock);
    if (state != InternalState::SLEEPING) {
-      return returnvalue::OK;
+      return BUSY;
    }
    replyWasReceived = this->replyWasReceived;
  }
@ -733,7 +728,7 @@ ReturnValue_t StrComHandler::readReceivedMessage(CookieIF* cookie, uint8_t** buf
    *size = replyLen;
  }
  replyLen = 0;
-  return returnvalue::OK;
+  return replyResult;
 }

 ReturnValue_t StrComHandler::unlockAndEraseRegions(uint32_t from, uint32_t to) {
@ -787,10 +782,8 @@ ReturnValue_t StrComHandler::handleSerialReception() {
               << std::endl;
    return FAILED;
  } else if (bytesRead > 0) {
-    if (PACKET_WIRETAPPING) {
-      sif::info << "Received " << bytesRead << " bytes from the STR" << std::endl;
-      arrayprinter::print(recBuf.data(), bytesRead);
-    }
+    // sif::info << "Received " << bytesRead << " bytes from the STR" << std::endl;
+    // arrayprinter::print(recBuf.data(), bytesRead);
    datalinkLayer.feedData(recBuf.data(), bytesRead);
  }
  return OK;
@ -804,10 +797,6 @@ ReturnValue_t StrComHandler::readOneReply(uint32_t failParameter) {
    handleSerialReception();
    result = datalinkLayer.checkRingBufForFrame(&replyPtr, replyLen);
    if (result == returnvalue::OK) {
-      if (PACKET_WIRETAPPING) {
-        sif::debug << "Received STR reply frame" << std::endl;
-        arrayprinter::print(replyPtr, replyLen);
-      }
      return returnvalue::OK;
    } else if (result != ArcsecDatalinkLayer::DEC_IN_PROGRESS) {
      triggerEvent(STR_HELPER_DEC_ERROR, result, failParameter);
--- a/linux/fsfwconfig/events/translateEvents.cpp
+++ b/linux/fsfwconfig/events/translateEvents.cpp
@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 301 translations.
+ * @brief    Auto-generated event translation file. Contains 295 translations.
 * @details
- * Generated on: 2023-07-26 12:51:20
+ * Generated on: 2023-05-17 17:15:34
 */
 #include "translateEvents.h"

@ -139,7 +139,6 @@ const char *ERROR_STATE_STRING = "ERROR_STATE";
 const char *RESET_OCCURED_STRING = "RESET_OCCURED";
 const char *BOOTING_FIRMWARE_FAILED_EVENT_STRING = "BOOTING_FIRMWARE_FAILED_EVENT";
 const char *BOOTING_BOOTLOADER_FAILED_EVENT_STRING = "BOOTING_BOOTLOADER_FAILED_EVENT";
-const char *COM_ERROR_REPLY_RECEIVED_STRING = "COM_ERROR_REPLY_RECEIVED";
 const char *SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING = "SUPV_MEMORY_READ_RPT_CRC_FAILURE";
 const char *SUPV_UNKNOWN_TM_STRING = "SUPV_UNKNOWN_TM";
 const char *SUPV_UNINIMPLEMENTED_TM_STRING = "SUPV_UNINIMPLEMENTED_TM";
@ -278,8 +277,6 @@ const char *INDIVIDUAL_BOOT_COUNTS_STRING = "INDIVIDUAL_BOOT_COUNTS";
 const char *TRYING_I2C_RECOVERY_STRING = "TRYING_I2C_RECOVERY";
 const char *I2C_REBOOT_STRING = "I2C_REBOOT";
 const char *PDEC_REBOOT_STRING = "PDEC_REBOOT";
-const char *FIRMWARE_INFO_STRING = "FIRMWARE_INFO";
-const char *ACTIVE_SD_INFO_STRING = "ACTIVE_SD_INFO";
 const char *NO_VALID_SENSOR_TEMPERATURE_STRING = "NO_VALID_SENSOR_TEMPERATURE";
 const char *NO_HEALTHY_HEATER_AVAILABLE_STRING = "NO_HEALTHY_HEATER_AVAILABLE";
 const char *SYRLINKS_OVERHEATING_STRING = "SYRLINKS_OVERHEATING";
@ -288,9 +285,6 @@ const char *CAMERA_OVERHEATING_STRING = "CAMERA_OVERHEATING";
 const char *PCDU_SYSTEM_OVERHEATING_STRING = "PCDU_SYSTEM_OVERHEATING";
 const char *HEATER_NOT_OFF_FOR_OFF_MODE_STRING = "HEATER_NOT_OFF_FOR_OFF_MODE";
 const char *MGT_OVERHEATING_STRING = "MGT_OVERHEATING";
-const char *TCS_SWITCHING_HEATER_ON_STRING = "TCS_SWITCHING_HEATER_ON";
-const char *TCS_SWITCHING_HEATER_OFF_STRING = "TCS_SWITCHING_HEATER_OFF";
-const char *TCS_HEATER_MAX_BURN_TIME_REACHED_STRING = "TCS_HEATER_MAX_BURN_TIME_REACHED";
 const char *TX_TIMER_EXPIRED_STRING = "TX_TIMER_EXPIRED";
 const char *BIT_LOCK_TX_ON_STRING = "BIT_LOCK_TX_ON";
 const char *POSSIBLE_FILE_CORRUPTION_STRING = "POSSIBLE_FILE_CORRUPTION";
@ -577,8 +571,6 @@ const char *translateEvents(Event event) {
      return BOOTING_FIRMWARE_FAILED_EVENT_STRING;
    case (11902):
      return BOOTING_BOOTLOADER_FAILED_EVENT_STRING;
-    case (11903):
-      return COM_ERROR_REPLY_RECEIVED_STRING;
    case (12001):
      return SUPV_MEMORY_READ_RPT_CRC_FAILURE_STRING;
    case (12002):
@ -855,10 +847,6 @@ const char *translateEvents(Event event) {
      return I2C_REBOOT_STRING;
    case (14012):
      return PDEC_REBOOT_STRING;
-    case (14013):
-      return FIRMWARE_INFO_STRING;
-    case (14014):
-      return ACTIVE_SD_INFO_STRING;
    case (14100):
      return NO_VALID_SENSOR_TEMPERATURE_STRING;
    case (14101):
@ -875,12 +863,6 @@ const char *translateEvents(Event event) {
      return HEATER_NOT_OFF_FOR_OFF_MODE_STRING;
    case (14108):
      return MGT_OVERHEATING_STRING;
-    case (14109):
-      return TCS_SWITCHING_HEATER_ON_STRING;
-    case (14110):
-      return TCS_SWITCHING_HEATER_OFF_STRING;
-    case (14111):
-      return TCS_HEATER_MAX_BURN_TIME_REACHED_STRING;
    case (14201):
      return TX_TIMER_EXPIRED_STRING;
    case (14202):
--- a/linux/fsfwconfig/objects/translateObjects.cpp
+++ b/linux/fsfwconfig/objects/translateObjects.cpp
@ -2,7 +2,7 @@
 * @brief  Auto-generated object translation file.
 * @details
 * Contains 175 translations.
- * Generated on: 2023-07-26 12:51:20
+ * Generated on: 2023-05-17 17:15:34
 */
 #include "translateObjects.h"

--- a/linux/ipcore/AxiPtmeConfig.cpp
+++ b/linux/ipcore/AxiPtmeConfig.cpp
@ -16,9 +16,9 @@ AxiPtmeConfig::AxiPtmeConfig(object_id_t objectId, std::string axiUio, int mapNu
 AxiPtmeConfig::~AxiPtmeConfig() {}

 ReturnValue_t AxiPtmeConfig::initialize() {
+  ReturnValue_t result = returnvalue::OK;
  UioMapper uioMapper(axiUio, mapNum);
-  ReturnValue_t result =
-      uioMapper.getMappedAdress(&baseAddress, UioMapper::Permissions::READ_WRITE);
+  result = uioMapper.getMappedAdress(&baseAddress, UioMapper::Permissions::READ_WRITE);
  if (result != returnvalue::OK) {
    return result;
  }
@ -26,7 +26,8 @@ ReturnValue_t AxiPtmeConfig::initialize() {
 }

 ReturnValue_t AxiPtmeConfig::writeCaduRateReg(uint8_t rateVal) {
-  ReturnValue_t result = mutex->lockMutex(timeoutType, mutexTimeout);
+  ReturnValue_t result = returnvalue::OK;
+  result = mutex->lockMutex(timeoutType, mutexTimeout);
  if (result != returnvalue::OK) {
    sif::warning << "AxiPtmeConfig::writeCaduRateReg: Failed to lock mutex" << std::endl;
    return returnvalue::FAILED;
@ -40,11 +41,6 @@ ReturnValue_t AxiPtmeConfig::writeCaduRateReg(uint8_t rateVal) {
  return returnvalue::OK;
 }

-uint8_t AxiPtmeConfig::readCaduRateReg() {
-  MutexGuard mg(mutex);
-  return static_cast<uint8_t>(*(baseAddress + CADU_BITRATE_REG));
-}
-
 void AxiPtmeConfig::enableTxclockManipulator() {
  writeBit(COMMON_CONFIG_REG, true, BitPos::EN_TX_CLK_MANIPULATOR);
 }
--- a/linux/ipcore/AxiPtmeConfig.h
+++ b/linux/ipcore/AxiPtmeConfig.h
@ -38,7 +38,6 @@ class AxiPtmeConfig : public SystemObject {
   *        frequency of the clock connected to the bit clock input of PTME.
   */
  ReturnValue_t writeCaduRateReg(uint8_t rateVal);
-  uint8_t readCaduRateReg();

  /**
   * @brief Next to functions control the tx clock manipulator component
--- a/linux/ipcore/PapbVcInterface.cpp
+++ b/linux/ipcore/PapbVcInterface.cpp
@ -7,16 +7,20 @@

 #include "fsfw/serviceinterface/ServiceInterface.h"

-PapbVcInterface::PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbEmptyId,
-                                 std::string uioFile, int mapNum)
-    : gpioComIF(gpioComIF), papbEmptyId(papbEmptyId), uioFile(std::move(uioFile)), mapNum(mapNum) {}
+PapbVcInterface::PapbVcInterface(LinuxLibgpioIF* gpioComIF, gpioId_t papbBusyId,
+                                 gpioId_t papbEmptyId, std::string uioFile, int mapNum)
+    : gpioComIF(gpioComIF),
+      papbBusyId(papbBusyId),
+      papbEmptyId(papbEmptyId),
+      uioFile(std::move(uioFile)),
+      mapNum(mapNum) {}

 PapbVcInterface::~PapbVcInterface() {}

 ReturnValue_t PapbVcInterface::initialize() {
  UioMapper uioMapper(uioFile, mapNum);
  ReturnValue_t result = uioMapper.getMappedAdress(const_cast<uint32_t**>(&vcBaseReg),
-                                                   UioMapper::Permissions::READ_WRITE);
+                                                   UioMapper::Permissions::WRITE_ONLY);
  if (result != returnvalue::OK) {
    return result;
  }
@ -28,27 +32,63 @@ ReturnValue_t PapbVcInterface::write(const uint8_t* data, size_t size) {
  if (size < 4) {
    return returnvalue::FAILED;
  }
-  if (pollReadyForPacket()) {
+  if (pollInterfaceReadiness(0, true) == returnvalue::OK) {
    startPacketTransfer(ByteWidthCfg::ONE);
  } else {
    return DirectTmSinkIF::IS_BUSY;
  }
-  if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
-    abortPacketTransfer();
-    return returnvalue::FAILED;
-  }
+  // TODO: This should work but does not.. :(
+  //  size_t idx = 0;
+  //  while (idx < size) {
+  //
+  //    nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
+  //    if ((size - idx) < 4) {
+  //      *vcBaseReg = CONFIG_DATA_INPUT | (size - idx - 1);
+  //      usleep(1);
+  //    }
+  //    if (pollPapbBusySignal(2) == returnvalue::OK) {
+  //      //      vcBaseReg + DATA_REG_OFFSET + 3 = static_cast<uint8_t>(data + idx);
+  //      //      vcBaseReg + DATA_REG_OFFSET + 2 = static_cast<uint8_t>(data + idx + 1);
+  //      //      vcBaseReg + DATA_REG_OFFSET + 1 = static_cast<uint8_t>(data + idx + 2);
+  //      //      vcBaseReg + DATA_REG_OFFSET = static_cast<uint8_t>(data + idx + 3);
+  //
+  //      // std::memcpy((vcBaseReg + DATA_REG_OFFSET), data + idx , nextWriteSize);
+  //      *(vcBaseReg + DATA_REG_OFFSET) = *reinterpret_cast<const uint32_t*>(data + idx);
+  //      //uint8_t* byteReg = reinterpret_cast<uint8_t*>(vcBaseReg + DATA_REG_OFFSET);
+  //
+  //      //byteReg[0] = data[idx];
+  //      //byteReg[1] = data[idx];
+  //    } else {
+  //      abortPacketTransfer();
+  //      return returnvalue::FAILED;
+  //    }
+  //    // TODO: Change this after the bugfix. Right now, the PAPB ignores the content of the byte
+  //    // width configuration.5
+  //    // It's okay to increment by a larger amount for the last segment here, loop will be over
+  //    // in any case.
+  //    idx += 4;
+  //  }
  for (size_t idx = 0; idx < size; idx++) {
-    if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
+    // This delay is super-important, DO NOT REMOVE!
+    // Polling the GPIO or the config register too often messes up the scheduler.
+    // TODO: Maybe this should not be done like this. It would be better if there was a custom
+    // FPGA module which can accept packets and then takes care of dumping that packet into
+    // the PTME. DMA would be an ideal solution for this.
+    nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
+    if (pollInterfaceReadiness(2, false) == returnvalue::OK) {
+      *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[idx]);
+    } else {
      abortPacketTransfer();
      return returnvalue::FAILED;
    }
-    *(vcBaseReg + DATA_REG_OFFSET) = static_cast<uint32_t>(data[idx]);
  }
-  if (not pollReadyForOctet(MAX_BUSY_POLLS)) {
+  nanosleep(&BETWEEN_POLL_DELAY, &remDelay);
+  if (pollInterfaceReadiness(2, false) == returnvalue::OK) {
+    completePacketTransfer();
+  } else {
    abortPacketTransfer();
    return returnvalue::FAILED;
  }
-  completePacketTransfer();
  return returnvalue::OK;
 }

@ -58,49 +98,63 @@ void PapbVcInterface::startPacketTransfer(ByteWidthCfg 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;
+ReturnValue_t PapbVcInterface::pollInterfaceReadiness(uint32_t maxPollRetries,
+                                                      bool checkReadyState) const {
+  uint32_t busyIdx = 0;
+  nextDelay.tv_nsec = FIRST_DELAY_PAPB_POLLING_NS;
+
+  while (true) {
+    // 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;
+    bool busy = (reg >> 5) & 0b1;
+    bool ready = (reg >> 6) & 0b1;
+    if (not busy) {
+      return returnvalue::OK;
+    }
+    if (checkReadyState and not ready) {
+      return PAPB_BUSY;
+    }
+
+    busyIdx++;
+    if (busyIdx >= maxPollRetries) {
+      return PAPB_BUSY;
+    }
+
+    // Ignore signal handling here for now.
+    nanosleep(&nextDelay, &remDelay);
+    // Adaptive delay.
+    if (nextDelay.tv_nsec * 2 <= MAX_DELAY_PAPB_POLLING_NS) {
+      nextDelay.tv_nsec *= 2;
+    }
+  }
+  return returnvalue::OK;
 }

-bool PapbVcInterface::isVcInterfaceBufferEmpty() {
+void PapbVcInterface::isVcInterfaceBufferEmpty() {
  ReturnValue_t result = returnvalue::OK;
  gpio::Levels papbEmptyState = gpio::Levels::HIGH;

  result = gpioComIF->readGpio(papbEmptyId, papbEmptyState);

  if (result != returnvalue::OK) {
-    sif::error << "PapbVcInterface::isVcInterfaceBufferEmpty: Failed to read papb empty signal"
-               << std::endl;
-    return true;
+    sif::warning << "PapbVcInterface::isVcInterfaceBufferEmpty: Failed to read papb empty signal"
+                 << std::endl;
+    return;
  }

  if (papbEmptyState == gpio::Levels::HIGH) {
-    return true;
+    sif::debug << "PapbVcInterface::isVcInterfaceBufferEmpty: Buffer is empty" << std::endl;
+  } else {
+    sif::debug << "PapbVcInterface::isVcInterfaceBufferEmpty: Buffer is not empty" << std::endl;
  }
-  return false;
+  return;
 }

-bool PapbVcInterface::isBusy() const { return not pollReadyForPacket(); }
+bool PapbVcInterface::isBusy() const { return pollInterfaceReadiness(0, true) == PAPB_BUSY; }

 void PapbVcInterface::cancelTransfer() { abortPacketTransfer(); }

-inline bool PapbVcInterface::pollReadyForOctet(uint32_t maxCycles) const {
-  uint32_t reg;
-  uint32_t idx = 0;
-  while (idx < maxCycles) {
-    reg = *vcBaseReg;
-    // Busy bit.
-    if (not((reg >> 5) & 0b1)) {
-      return true;
-    }
-    idx++;
-  }
-  return false;
-}
-
 ReturnValue_t PapbVcInterface::sendTestFrame() {
  /** Size of one complete transfer frame data field amounts to 1105 bytes */
  uint8_t testPacket[1105];
--- a/linux/ipcore/PapbVcInterface.h
+++ b/linux/ipcore/PapbVcInterface.h
@ -30,7 +30,8 @@ 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 papbBusyId, gpioId_t papbEmptyId,
+                  std::string uioFile, int mapNum);
  virtual ~PapbVcInterface();

  bool isBusy() const override;
@ -80,9 +81,11 @@ class PapbVcInterface : public VirtualChannelIF {

  static constexpr long int FIRST_DELAY_PAPB_POLLING_NS = 10;
  static constexpr long int MAX_DELAY_PAPB_POLLING_NS = 40;
-  static constexpr uint32_t MAX_BUSY_POLLS = 1000;

  LinuxLibgpioIF* gpioComIF = nullptr;
+
+  /** Pulled to low when virtual channel not ready to receive data */
+  gpioId_t papbBusyId = gpio::NO_GPIO;
  /** High when external buffer memory of virtual channel is empty */
  gpioId_t papbEmptyId = gpio::NO_GPIO;

@ -117,15 +120,13 @@ class PapbVcInterface : public VirtualChannelIF {
   *
   * @return  returnvalue::OK when ready to receive data else PAPB_BUSY.
   */
-  inline bool pollReadyForPacket() const;
-
-  inline bool pollReadyForOctet(uint32_t maxCycles) const;
+  inline ReturnValue_t pollInterfaceReadiness(uint32_t maxPollRetries, bool checkReadyState) const;

  /**
   * @brief   This function can be used for debugging to check whether there are packets in
   *          the packet buffer of the virtual channel or not.
   */
-  bool isVcInterfaceBufferEmpty();
+  void isVcInterfaceBufferEmpty();

  /**
   * @brief   This function sends a complete telemetry transfer frame data field (1105 bytes)
--- a/linux/ipcore/PtmeConfig.cpp
+++ b/linux/ipcore/PtmeConfig.cpp
@ -26,11 +26,6 @@ ReturnValue_t PtmeConfig::setRate(uint32_t bitRate) {
  return axiPtmeConfig->writeCaduRateReg(static_cast<uint8_t>(rateVal));
 }

-uint32_t PtmeConfig::getRate() {
-  uint8_t rateReg = axiPtmeConfig->readCaduRateReg();
-  return (BIT_CLK_FREQ / (rateReg + 1));
-}
-
 void PtmeConfig::invertTxClock(bool invert) {
  if (invert) {
    axiPtmeConfig->enableTxclockInversion();
--- a/linux/ipcore/PtmeConfig.h
+++ b/linux/ipcore/PtmeConfig.h
@ -32,7 +32,6 @@ class PtmeConfig : public SystemObject {
   *          of the CADU clock due to the convolutional code added by the s-Band transceiver.
   */
  ReturnValue_t setRate(uint32_t bitRate);
-  uint32_t getRate();

  /**
   * @brief Will change the time the tx data signal is updated with respect to the tx clock
--- a/misc/eclipse/.cproject
+++ b/misc/eclipse/.cproject
@ -57,8 +57,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
-						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
+						<entry excluding="cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -120,8 +119,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
-						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
+						<entry excluding="cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -189,8 +187,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
-						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
+						<entry excluding="cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -258,8 +255,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
-						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
+						<entry excluding="cmake-build-debug-q7s-em|cmake-build-debug-q7s|bsp_q7s|cmake-build-debug/_deps|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -422,8 +418,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="unittest/rebootLogic|thirdparty/json|build-Debug-RPi/_deps/etl-src/uml|build-Debug-RPi/_deps/etl-src/test|build-Debug-RPi/_deps/etl-src/temp|build-Debug-RPi/_deps/etl-src/support|build-Debug-RPi/_deps/etl-src/subprojects|build-Debug-RPi/_deps/etl-src/scripts|build-Debug-RPi/_deps/etl-src/images|build-Debug-RPi/_deps/etl-src/examples|build-Debug-RPi/_deps/etl-src/cmake|build-Debug-RPi/_deps/etl-src/arduino|cmake-build-debug-q7s|cmake-build-debug|cmake-build-debug-q7s-em|cmake-build-release-q7s-em|bsp_hosted|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
-						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
+						<entry excluding="build-Debug-RPi/_deps/etl-src/uml|build-Debug-RPi/_deps/etl-src/test|build-Debug-RPi/_deps/etl-src/temp|build-Debug-RPi/_deps/etl-src/support|build-Debug-RPi/_deps/etl-src/subprojects|build-Debug-RPi/_deps/etl-src/scripts|build-Debug-RPi/_deps/etl-src/images|build-Debug-RPi/_deps/etl-src/examples|build-Debug-RPi/_deps/etl-src/cmake|build-Debug-RPi/_deps/etl-src/arduino|cmake-build-debug-q7s|cmake-build-debug|cmake-build-debug-q7s-em|cmake-build-release-q7s-em|bsp_hosted|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -585,8 +580,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="unittest/rebootLogic|thirdparty/json|build-Debug-RPi/_deps/etl-src/uml|build-Debug-RPi/_deps/etl-src/test|build-Debug-RPi/_deps/etl-src/temp|build-Debug-RPi/_deps/etl-src/support|build-Debug-RPi/_deps/etl-src/subprojects|build-Debug-RPi/_deps/etl-src/scripts|build-Debug-RPi/_deps/etl-src/images|build-Debug-RPi/_deps/etl-src/examples|build-Debug-RPi/_deps/etl-src/cmake|build-Debug-RPi/_deps/etl-src/arduino|cmake-build-debug-q7s|cmake-build-debug|cmake-build-debug-q7s-em|cmake-build-release-q7s-em|bsp_hosted|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
-						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
+						<entry excluding="build-Debug-RPi/_deps/etl-src/uml|build-Debug-RPi/_deps/etl-src/test|build-Debug-RPi/_deps/etl-src/temp|build-Debug-RPi/_deps/etl-src/support|build-Debug-RPi/_deps/etl-src/subprojects|build-Debug-RPi/_deps/etl-src/scripts|build-Debug-RPi/_deps/etl-src/images|build-Debug-RPi/_deps/etl-src/examples|build-Debug-RPi/_deps/etl-src/cmake|build-Debug-RPi/_deps/etl-src/arduino|cmake-build-debug-q7s|cmake-build-debug|cmake-build-debug-q7s-em|cmake-build-release-q7s-em|bsp_hosted|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -756,8 +750,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-release-q7s-em|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug|cmake-build-debug-q7s-em|build-Debug-Host|build-Watchdog-Debug" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
-						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
+						<entry excluding="cmake-build-release-q7s-em|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug|cmake-build-debug-q7s-em|build-Debug-Host|build-Watchdog-Debug" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -924,8 +917,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s|cmake-build-release-q7s-em|cmake-build-release-q7s/_deps/etl-src/uml|cmake-build-release-q7s/_deps/etl-src/test|cmake-build-release-q7s/_deps/etl-src/temp|cmake-build-release-q7s/_deps/etl-src/support|cmake-build-release-q7s/_deps/etl-src/subprojects|cmake-build-release-q7s/_deps/etl-src/scripts|cmake-build-release-q7s/_deps/etl-src/images|cmake-build-release-q7s/_deps/etl-src/examples|cmake-build-release-q7s/_deps/etl-src/cmake|cmake-build-release-q7s/_deps/etl-src/arduino|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug|cmake-build-debug-q7s-em|build-Debug-Host|build-Watchdog-Debug" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
-						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
+						<entry excluding="cmake-build-debug-q7s|cmake-build-release-q7s-em|cmake-build-release-q7s/_deps/etl-src/uml|cmake-build-release-q7s/_deps/etl-src/test|cmake-build-release-q7s/_deps/etl-src/temp|cmake-build-release-q7s/_deps/etl-src/support|cmake-build-release-q7s/_deps/etl-src/subprojects|cmake-build-release-q7s/_deps/etl-src/scripts|cmake-build-release-q7s/_deps/etl-src/images|cmake-build-release-q7s/_deps/etl-src/examples|cmake-build-release-q7s/_deps/etl-src/cmake|cmake-build-release-q7s/_deps/etl-src/arduino|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug|cmake-build-debug-q7s-em|build-Debug-Host|build-Watchdog-Debug" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -1092,8 +1084,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em/_deps/etl-src|cmake-build-debug/_deps/etl-src/uml|cmake-build-debug/_deps/etl-src/test|cmake-build-debug/_deps/etl-src/temp|cmake-build-debug/_deps/etl-src/support|cmake-build-debug/_deps/etl-src/subprojects|cmake-build-debug/_deps/etl-src/scripts|cmake-build-debug/_deps/etl-src/images|cmake-build-debug/_deps/etl-src/examples|cmake-build-debug/_deps/etl-src/cmake|cmake-build-debug/_deps/etl-src/arduino|cmake-build-release-q7s-em|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
-						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
+						<entry excluding="cmake-build-debug/_deps/etl-src/uml|cmake-build-debug/_deps/etl-src/test|cmake-build-debug/_deps/etl-src/temp|cmake-build-debug/_deps/etl-src/support|cmake-build-debug/_deps/etl-src/subprojects|cmake-build-debug/_deps/etl-src/scripts|cmake-build-debug/_deps/etl-src/images|cmake-build-debug/_deps/etl-src/examples|cmake-build-debug/_deps/etl-src/cmake|cmake-build-debug/_deps/etl-src/arduino|cmake-build-release-q7s-em|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -1158,8 +1149,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em/_deps/etl-src|cmake-build-debug/_deps/etl-src/uml|cmake-build-debug/_deps/etl-src/test|cmake-build-debug/_deps/etl-src/temp|cmake-build-debug/_deps/etl-src/support|cmake-build-debug/_deps/etl-src/subprojects|cmake-build-debug/_deps/etl-src/scripts|cmake-build-debug/_deps/etl-src/images|cmake-build-debug/_deps/etl-src/examples|cmake-build-debug/_deps/etl-src/cmake|cmake-build-debug/_deps/etl-src/arduino|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
-						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
+						<entry excluding="cmake-build-debug/_deps/etl-src/uml|cmake-build-debug/_deps/etl-src/test|cmake-build-debug/_deps/etl-src/temp|cmake-build-debug/_deps/etl-src/support|cmake-build-debug/_deps/etl-src/subprojects|cmake-build-debug/_deps/etl-src/scripts|cmake-build-debug/_deps/etl-src/images|cmake-build-debug/_deps/etl-src/examples|cmake-build-debug/_deps/etl-src/cmake|cmake-build-debug/_deps/etl-src/arduino|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -1182,7 +1172,7 @@
 				</extensions>
 			</storageModule>
 			<storageModule moduleId="cdtBuildSystem" version="4.0.0">
-				<configuration artifactName="${ProjName}" buildProperties="" description="" errorParsers="org.eclipse.cdt.core.GASErrorParser;org.eclipse.cdt.core.GmakeErrorParser;org.eclipse.cdt.core.GLDErrorParser;org.eclipse.cdt.core.CWDLocator;org.eclipse.cdt.core.GCCErrorParser" id="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1171630561" name="eive-q7s-debug-em" optionalBuildProperties="org.eclipse.cdt.docker.launcher.containerbuild.property.enablement=null,org.eclipse.cdt.docker.launcher.containerbuild.property.dockerdpath=,org.eclipse.cdt.docker.launcher.containerbuild.property.volumes=,org.eclipse.cdt.docker.launcher.containerbuild.property.connection=unix:///var/run/docker.sock,org.eclipse.cdt.docker.launcher.containerbuild.property.selectedvolumes=,org.eclipse.cdt.docker.launcher.containerbuild.property.image=null" parent="org.eclipse.cdt.build.core.emptycfg">
+				<configuration artifactName="${ProjName}" buildProperties="" description="" errorParsers="org.eclipse.cdt.core.GASErrorParser;org.eclipse.cdt.core.GmakeErrorParser;org.eclipse.cdt.core.GLDErrorParser;org.eclipse.cdt.core.CWDLocator;org.eclipse.cdt.core.GCCErrorParser" id="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1171630561" name="eive-q7s-debug-em" optionalBuildProperties="org.eclipse.cdt.docker.launcher.containerbuild.property.enablement=null,org.eclipse.cdt.docker.launcher.containerbuild.property.selectedvolumes=,org.eclipse.cdt.docker.launcher.containerbuild.property.volumes=,org.eclipse.cdt.docker.launcher.containerbuild.property.image=null,org.eclipse.cdt.docker.launcher.containerbuild.property.connection=null" parent="org.eclipse.cdt.build.core.emptycfg">
 					<folderInfo id="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1171630561." name="/" resourcePath="">
 						<toolChain id="ilg.gnuarmeclipse.managedbuild.cross.toolchain.base.1640701365" name="Arm Cross GCC" superClass="ilg.gnuarmeclipse.managedbuild.cross.toolchain.base">
 							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.architecture.564607779" name="Architecture" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.architecture" value="ilg.gnuarmeclipse.managedbuild.cross.option.architecture.arm" valueType="enumerated"/>
@ -1327,9 +1317,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em/_deps/etl-src|cmake-build-debug-q7s|cmake-build-release-q7s-em|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug|build-Debug-Host|build-Watchdog-Debug" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
-						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="cmake-build-debug-q7s-em/_deps/etl-src/include"/>
-						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
+						<entry excluding="cmake-build-debug-q7s|cmake-build-release-q7s-em|build-Debug-RPi|bsp_hosted|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug|build-Debug-Host|build-Watchdog-Debug" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -1398,8 +1386,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="unittest/rebootLogic|thirdparty/json|cmake-build-debug-q7s-em/_deps/etl-src|cmake-build-debug/_deps/etl-src/uml|cmake-build-debug/_deps/etl-src/test|cmake-build-debug/_deps/etl-src/temp|cmake-build-debug/_deps/etl-src/support|cmake-build-debug/_deps/etl-src/subprojects|cmake-build-debug/_deps/etl-src/scripts|cmake-build-debug/_deps/etl-src/images|cmake-build-debug/_deps/etl-src/examples|cmake-build-debug/_deps/etl-src/cmake|cmake-build-debug/_deps/etl-src/arduino|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
-						<entry flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name="thirdparty/json/include"/>
+						<entry excluding="cmake-build-debug/_deps/etl-src/uml|cmake-build-debug/_deps/etl-src/test|cmake-build-debug/_deps/etl-src/temp|cmake-build-debug/_deps/etl-src/support|cmake-build-debug/_deps/etl-src/subprojects|cmake-build-debug/_deps/etl-src/scripts|cmake-build-debug/_deps/etl-src/images|cmake-build-debug/_deps/etl-src/examples|cmake-build-debug/_deps/etl-src/cmake|cmake-build-debug/_deps/etl-src/arduino|cmake-build-release-q7s-em|build-Debug-RPi|bsp_linux_board|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|scripts|bsp_te0720_1cfa|thirdparty/rapidcsv/tests|thirdparty/rapidcsv/examples|thirdparty/rapidcsv/doc|thirdparty/json/third_party|thirdparty/json/test|thirdparty/json/single_include|thirdparty/json/doc|thirdparty/json/cmake|thirdparty/json/benchmarks|archive|cmake-build-release-q7s|bsp_egse|cmake-build-debug-q7s/_deps/etl-src/test|fsfwconfig" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
--- a/mission/acs/SusHandler.cpp
+++ b/mission/acs/SusHandler.cpp
@ -30,7 +30,6 @@ void SusHandler::doStartUp() {
 void SusHandler::doShutDown() {
  if (internalState != InternalState::SHUTDOWN) {
    PoolReadGuard pg(&dataset);
-    dataset.tempC = thermal::INVALID_TEMPERATURE;
    dataset.setValidity(false, true);
    internalState = InternalState::SHUTDOWN;
    commandExecuted = false;
--- a/mission/acs/defs.h
+++ b/mission/acs/defs.h
@ -26,18 +26,10 @@ enum SafeModeStrategy : uint8_t {
  SAFECTRL_OFF = 0,
  SAFECTRL_NO_MAG_FIELD_FOR_CONTROL = 1,
  SAFECTRL_NO_SENSORS_FOR_CONTROL = 2,
-  // OBSW version <= v6.1.0
-  LEGACY_SAFECTRL_ACTIVE_MEKF = 10,
-  LEGACY_SAFECTRL_WITHOUT_MEKF = 11,
-  LEGACY_SAFECTRL_ECLIPSE_DAMPING = 12,
-  LEGACY_SAFECTRL_ECLIPSE_IDELING = 13,
-  // Added in v6.2.0
-  SAFECTRL_MEKF = 14,
-  SAFECTRL_GYR = 15,
-  SAFECTRL_SUSMGM = 16,
-  SAFECTRL_ECLIPSE_DAMPING_GYR = 17,
-  SAFECTRL_ECLIPSE_DAMPING_SUSMGM = 18,
-  SAFECTRL_ECLIPSE_IDELING = 19,
+  SAFECTRL_ACTIVE_MEKF = 10,
+  SAFECTRL_WITHOUT_MEKF = 11,
+  SAFECTRL_ECLIPSE_DAMPING = 12,
+  SAFECTRL_ECLIPSE_IDELING = 13,
  SAFECTRL_DETUMBLE_FULL = 20,
  SAFECTRL_DETUMBLE_DETERIORATED = 21,
 };
--- a/mission/acs/str/StarTrackerHandler.cpp
+++ b/mission/acs/str/StarTrackerHandler.cpp
@ -1,4 +1,3 @@
-#include <fsfw/globalfunctions/arrayprinter.h>
 #include <fsfw/ipc/QueueFactory.h>
 #include <fsfw/timemanager/Stopwatch.h>
 #include <mission/acs/str/StarTrackerHandler.h>
@ -19,7 +18,6 @@ extern "C" {

 #include "OBSWConfig.h"
 #include "eive/definitions.h"
-#include "fsfw/thermal/tcsDefinitions.h"

 std::atomic_bool JCFG_DONE(false);

@ -89,6 +87,7 @@ void StarTrackerHandler::doStartUp() {
    default:
      return;
  }
+  solutionSet.setReportingEnabled(true);
  startupState = StartupState::DONE;
  internalState = InternalState::IDLE;
  setMode(_MODE_TO_ON);
@ -112,9 +111,6 @@ void StarTrackerHandler::doShutDown() {
  }
  {
    PoolReadGuard pg(&temperatureSet);
-    temperatureSet.fpgaTemperature = thermal::INVALID_TEMPERATURE;
-    temperatureSet.cmosTemperature = thermal::INVALID_TEMPERATURE;
-    temperatureSet.mcuTemperature = thermal::INVALID_TEMPERATURE;
    temperatureSet.setValidity(false, true);
  }
  reinitNextSetParam = false;
@ -325,7 +321,7 @@ ReturnValue_t StarTrackerHandler::buildNormalDeviceCommand(DeviceCommandId_t* id
 ReturnValue_t StarTrackerHandler::buildTransitionDeviceCommand(DeviceCommandId_t* id) {
  switch (internalState) {
    case InternalState::BOOT_FIRMWARE: {
-      if (bootState == FwBootState::VERIFY_BOOT or isAwaitingReply()) {
+      if (bootState == FwBootState::WAIT_FOR_EXECUTION or bootState == FwBootState::VERIFY_BOOT) {
        return NOTHING_TO_SEND;
      }
      if (bootState == FwBootState::NONE) {
@ -349,69 +345,74 @@ ReturnValue_t StarTrackerHandler::buildTransitionDeviceCommand(DeviceCommandId_t
          *id = startracker::REQ_VERSION;
          return buildCommandFromCommand(*id, nullptr, 0);
        }
-        case (FwBootState::SET_TIME): {
-          *id = startracker::SET_TIME_FROM_SYS_TIME;
-          return buildCommandFromCommand(*id, nullptr, 0);
-        }
        case (FwBootState::LOGLEVEL): {
+          bootState = FwBootState::WAIT_FOR_EXECUTION;
          *id = startracker::LOGLEVEL;
          return buildCommandFromCommand(
              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
        }
        case (FwBootState::LIMITS): {
+          bootState = FwBootState::WAIT_FOR_EXECUTION;
          *id = startracker::LIMITS;
          return buildCommandFromCommand(
              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
        }
        case (FwBootState::TRACKING): {
+          bootState = FwBootState::WAIT_FOR_EXECUTION;
          *id = startracker::TRACKING;
          return buildCommandFromCommand(
              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
        }
        case FwBootState::MOUNTING:
+          bootState = FwBootState::WAIT_FOR_EXECUTION;
          *id = startracker::MOUNTING;
          return buildCommandFromCommand(
              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
        case FwBootState::IMAGE_PROCESSOR:
+          bootState = FwBootState::WAIT_FOR_EXECUTION;
          *id = startracker::IMAGE_PROCESSOR;
          return buildCommandFromCommand(
              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
        case FwBootState::CAMERA:
+          bootState = FwBootState::WAIT_FOR_EXECUTION;
          *id = startracker::CAMERA;
          return buildCommandFromCommand(
              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
        case FwBootState::CENTROIDING:
+          bootState = FwBootState::WAIT_FOR_EXECUTION;
          *id = startracker::CENTROIDING;
          return buildCommandFromCommand(
              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
        case FwBootState::LISA:
+          bootState = FwBootState::WAIT_FOR_EXECUTION;
          *id = startracker::LISA;
          return buildCommandFromCommand(
              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
        case FwBootState::MATCHING:
+          bootState = FwBootState::WAIT_FOR_EXECUTION;
          *id = startracker::MATCHING;
          return buildCommandFromCommand(
              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
        case FwBootState::VALIDATION:
+          bootState = FwBootState::WAIT_FOR_EXECUTION;
          *id = startracker::VALIDATION;
          return buildCommandFromCommand(
              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
        case FwBootState::ALGO:
+          bootState = FwBootState::WAIT_FOR_EXECUTION;
          *id = startracker::ALGO;
          return buildCommandFromCommand(
              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
        case FwBootState::LOG_SUBSCRIPTION:
+          bootState = FwBootState::WAIT_FOR_EXECUTION;
          *id = startracker::LOGSUBSCRIPTION;
          return buildCommandFromCommand(
              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
        case FwBootState::DEBUG_CAMERA:
+          bootState = FwBootState::WAIT_FOR_EXECUTION;
          *id = startracker::DEBUG_CAMERA;
          return buildCommandFromCommand(
              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
-        case FwBootState::AUTO_THRESHOLD:
-          *id = startracker::AUTO_THRESHOLD;
-          return buildCommandFromCommand(
-              *id, reinterpret_cast<const uint8_t*>(paramJsonFile.c_str()), paramJsonFile.size());
        default: {
          sif::error << "STR: Unexpected boot state" << (int)bootState << std::endl;
          return NOTHING_TO_SEND;
@ -454,20 +455,6 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
      preparePingRequest();
      return returnvalue::OK;
    }
-    case (startracker::SET_TIME_FROM_SYS_TIME): {
-      SetTimeActionRequest setTimeRequest{};
-      timeval tv;
-      Clock::getClock(&tv);
-      setTimeRequest.unixTime =
-          (static_cast<uint64_t>(tv.tv_sec) * 1000 * 1000) + (static_cast<uint64_t>(tv.tv_usec));
-      arc_pack_settime_action_req(&setTimeRequest, commandBuffer, &rawPacketLen);
-      size_t serLen = 0;
-      // Time in milliseconds. Manual serialization because arcsec API ignores endianness.
-      SerializeAdapter::serialize(&setTimeRequest.unixTime, commandBuffer + 2, &serLen,
-                                  sizeof(commandBuffer) - 2, SerializeIF::Endianness::LITTLE);
-      rawPacket = commandBuffer;
-      return returnvalue::OK;
-    }
    case (startracker::REQ_TIME): {
      prepareTimeRequest();
      return returnvalue::OK;
@ -560,11 +547,6 @@ ReturnValue_t StarTrackerHandler::buildCommandFromCommand(DeviceCommandId_t devi
      result = prepareParamCommand(commandData, commandDataLen, jcfgs.logLevel, reinitNextSetParam);
      return result;
    }
-    case (startracker::AUTO_THRESHOLD): {
-      result =
-          prepareParamCommand(commandData, commandDataLen, jcfgs.autoThreshold, reinitNextSetParam);
-      return result;
-    }
    case (startracker::LOGSUBSCRIPTION): {
      result = prepareParamCommand(commandData, commandDataLen, jcfgs.logSubscription,
                                   reinitNextSetParam);
@ -669,23 +651,19 @@ void StarTrackerHandler::fillCommandAndReplyMap() {
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::LOGLEVEL, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
-  this->insertInCommandAndReplyMap(startracker::SET_TIME_FROM_SYS_TIME, 2, nullptr,
-                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::LOGSUBSCRIPTION, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::DEBUG_CAMERA, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::LIMITS, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
-  this->insertInCommandAndReplyMap(startracker::AUTO_THRESHOLD, 2, nullptr,
-                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::MOUNTING, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::IMAGE_PROCESSOR, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::CAMERA, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
-  this->insertInCommandAndReplyMap(startracker::CENTROIDING, 2, nullptr,
+  this->insertInCommandAndReplyMap(startracker::CENTROIDING, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
  this->insertInCommandAndReplyMap(startracker::LISA, 3, nullptr,
                                   startracker::MAX_FRAME_SIZE * 2 + 2);
@ -832,7 +810,6 @@ void StarTrackerHandler::bootFirmware(Mode_t toMode) {
        setMode(toMode, startracker::SUBMODE_FIRMWARE);
      }
      sif::info << "STR: Firmware boot success" << std::endl;
-      solutionSet.setReportingEnabled(true);
      internalState = InternalState::IDLE;
      startupState = StartupState::IDLE;
      break;
@ -856,7 +833,6 @@ void StarTrackerHandler::setUpJsonCfgs(JsonConfigs& cfgs, const char* paramJsonF
  cfgs.mounting.init(paramJsonFile);
  cfgs.limits.init(paramJsonFile);
  cfgs.subscription.init(paramJsonFile);
-  cfgs.autoThreshold.init(paramJsonFile);
  JCFG_DONE = true;
 }

@ -880,20 +856,13 @@ ReturnValue_t StarTrackerHandler::scanForReply(const uint8_t* start, size_t rema
    *foundLen = remainingSize;
    return returnvalue::OK;
  }
-  if (remainingSize < 2) {
-    sif::error << "StarTrackerHandler: Reply packet with length " << remainingSize
-               << "  less than "
-                  "2 is invalid"
+  if (remainingSize < 3) {
+    sif::error << "StarTrackerHandler: Reply packet with length less than 3 is invalid"
               << std::endl;
    return returnvalue::FAILED;
  }

  switch (startracker::getReplyFrameType(start)) {
-    case TMTC_COMM_ERROR: {
-      *foundLen = remainingSize;
-      triggerEvent(COM_ERROR_REPLY_RECEIVED, start[1]);
-      break;
-    }
    case TMTC_ACTIONREPLY: {
      *foundLen = remainingSize;
      return scanForActionReply(startracker::getId(start), foundId);
@ -928,10 +897,6 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
  ReturnValue_t result = returnvalue::OK;

  switch (id) {
-    case (startracker::SET_TIME_FROM_SYS_TIME): {
-      result = handleActionReply(packet);
-      break;
-    }
    case (startracker::REQ_TIME): {
      result = handleTm(packet, timeSet, startracker::TimeSet::SIZE, "REQ_TIME");
      break;
@ -991,8 +956,7 @@ ReturnValue_t StarTrackerHandler::interpretDeviceReply(DeviceCommandId_t id,
    case (startracker::TRACKING):
    case (startracker::VALIDATION):
    case (startracker::IMAGE_PROCESSOR):
-    case (startracker::ALGO):
-    case (startracker::AUTO_THRESHOLD): {
+    case (startracker::ALGO): {
      result = handleSetParamReply(packet);
      break;
    }
@ -1399,10 +1363,6 @@ ReturnValue_t StarTrackerHandler::scanForActionReply(uint8_t replyId, DeviceComm
      *foundId = startracker::UPLOAD_IMAGE;
      break;
    }
-    case (ARC_ACTION_REQ_SETTIME_ID): {
-      *foundId = startracker::SET_TIME_FROM_SYS_TIME;
-      break;
-    }
    case (startracker::ID::CHECKSUM): {
      *foundId = startracker::CHECKSUM;
      break;
@ -1470,10 +1430,6 @@ ReturnValue_t StarTrackerHandler::scanForSetParameterReply(uint8_t replyId,
      *foundId = startracker::DEBUG_CAMERA;
      break;
    }
-    case (startracker::ID::AUTO_THRESHOLD): {
-      *foundId = startracker::AUTO_THRESHOLD;
-      break;
-    }
    case (startracker::ID::LOG_SUBSCRIPTION): {
      *foundId = startracker::LOGSUBSCRIPTION;
      break;
@ -1901,7 +1857,7 @@ ReturnValue_t StarTrackerHandler::handleSetParamReply(const uint8_t* rawFrame) {
  uint8_t status = startracker::getStatusField(rawFrame);
  if (status != startracker::STATUS_OK) {
    sif::warning << "StarTrackerHandler::handleSetParamReply: Failed to execute parameter set "
-                    "command with parameter ID "
+                    " command with parameter ID"
                 << static_cast<unsigned int>(*(rawFrame + PARAMETER_ID_OFFSET)) << std::endl;
    if (internalState != InternalState::IDLE) {
      internalState = InternalState::IDLE;
@ -1909,25 +1865,21 @@ ReturnValue_t StarTrackerHandler::handleSetParamReply(const uint8_t* rawFrame) {
    return SET_PARAM_FAILED;
  }
  if (internalState != InternalState::IDLE) {
-    handleStartup(*rawFrame, *(rawFrame + PARAMETER_ID_OFFSET));
+    handleStartup(*(rawFrame + PARAMETER_ID_OFFSET));
  }
  return returnvalue::OK;
 }

 ReturnValue_t StarTrackerHandler::handleActionReply(const uint8_t* rawFrame) {
  uint8_t status = startracker::getStatusField(rawFrame);
-  ReturnValue_t result = returnvalue::OK;
  if (status != startracker::STATUS_OK) {
    sif::warning << "StarTrackerHandler::handleActionReply: Failed to execute action "
                 << "command with action ID "
                 << static_cast<unsigned int>(*(rawFrame + ACTION_ID_OFFSET)) << " and status "
                 << static_cast<unsigned int>(status) << std::endl;
-    result = ACTION_FAILED;
+    return ACTION_FAILED;
  }
-  if (internalState != InternalState::IDLE) {
-    handleStartup(*rawFrame, *(rawFrame + PARAMETER_ID_OFFSET));
-  }
-  return result;
+  return returnvalue::OK;
 }

 ReturnValue_t StarTrackerHandler::handleChecksumReply(const uint8_t* rawFrame) {
@ -2023,7 +1975,7 @@ ReturnValue_t StarTrackerHandler::checkProgram() {
        startupState = StartupState::BOOT_BOOTLOADER;
      }
      if (bootState == FwBootState::VERIFY_BOOT) {
-        bootState = FwBootState::SET_TIME;
+        bootState = FwBootState::LOGLEVEL;
      } else if (internalState == InternalState::BOOTLOADER_CHECK) {
        triggerEvent(BOOTING_BOOTLOADER_FAILED_EVENT);
        internalState = InternalState::FAILED_BOOTLOADER_BOOT;
@ -2100,18 +2052,7 @@ ReturnValue_t StarTrackerHandler::handleActionReplySet(const uint8_t* rawFrame,
  return result;
 }

-void StarTrackerHandler::handleStartup(uint8_t tmType, uint8_t parameterId) {
-  switch (tmType) {
-    case (TMTC_ACTIONREPLY): {
-      case (ARC_ACTION_REQ_SETTIME_ID): {
-        bootState = FwBootState::LOGLEVEL;
-        return;
-      }
-      default: {
-        break;
-      }
-    }
-  }
+void StarTrackerHandler::handleStartup(uint8_t parameterId) {
  switch (parameterId) {
    case (startracker::ID::LOG_LEVEL): {
      bootState = FwBootState::LIMITS;
@ -2121,7 +2062,7 @@ void StarTrackerHandler::handleStartup(uint8_t tmType, uint8_t parameterId) {
      bootState = FwBootState::TRACKING;
      break;
    }
-    case (ARC_PARAM_TRACKING_ID): {
+    case (startracker::ID::TRACKING): {
      bootState = FwBootState::MOUNTING;
      break;
    }
@ -2162,10 +2103,6 @@ void StarTrackerHandler::handleStartup(uint8_t tmType, uint8_t parameterId) {
      break;
    }
    case (startracker::ID::DEBUG_CAMERA): {
-      bootState = FwBootState::AUTO_THRESHOLD;
-      break;
-    }
-    case (startracker::ID::AUTO_THRESHOLD): {
      bootState = FwBootState::NONE;
      internalState = InternalState::DONE;
      break;
--- a/mission/acs/str/StarTrackerHandler.h
+++ b/mission/acs/str/StarTrackerHandler.h
@ -6,7 +6,6 @@
 #include <mission/acs/str/ArcsecJsonParamBase.h>
 #include <mission/acs/str/strHelpers.h>
 #include <mission/acs/str/strJsonCommands.h>
-#include <thirdparty/sagittactl/wire/common/genericstructs.h>

 #include <thread>

@ -17,7 +16,7 @@
 #include "fsfw/timemanager/Countdown.h"

 extern "C" {
-#include <wire/common/genericstructs.h>
+#include <wire/common/SLIP.h>
 }

 /**
@ -144,8 +143,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
  static const Event BOOTING_FIRMWARE_FAILED_EVENT = MAKE_EVENT(1, severity::LOW);
  //! [EXPORT] : [COMMENT] Failed to boot star tracker into bootloader mode
  static const Event BOOTING_BOOTLOADER_FAILED_EVENT = MAKE_EVENT(2, severity::LOW);
-  //! [EXPORT] : [COMMENT] Received COM error. P1:  Communication Error ID (datasheet p32)
-  static constexpr Event COM_ERROR_REPLY_RECEIVED = MAKE_EVENT(3, severity::LOW);

  static const uint8_t STATUS_OFFSET = 2;
  static const uint8_t PARAMS_OFFSET = 2;
@ -229,7 +226,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
    Mounting mounting;
    Limits limits;
    Subscription subscription;
-    AutoThreshold autoThreshold;
  };
  JsonConfigs jcfgs;
  Countdown jcfgCountdown = Countdown(250);
@ -268,7 +264,6 @@ class StarTrackerHandler : public DeviceHandlerBase {
    BOOT_DELAY,
    REQ_VERSION,
    VERIFY_BOOT,
-    SET_TIME,
    LOGLEVEL,
    LIMITS,
    TRACKING,
@ -283,9 +278,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
    ALGO,
    LOG_SUBSCRIPTION,
    DEBUG_CAMERA,
-    AUTO_THRESHOLD,
    WAIT_FOR_EXECUTION,
-    RETRY_CFG_CMD
  };
  FwBootState bootState = FwBootState::NONE;

@ -475,7 +468,7 @@ class StarTrackerHandler : public DeviceHandlerBase {
  /**
   * @brief   Handles the startup state machine
   */
-  void handleStartup(uint8_t tmType, uint8_t parameterId);
+  void handleStartup(uint8_t parameterId);

  /**
   * @brief   Handles telemtry replies and fills the appropriate dataset
--- a/mission/acs/str/arcsecJsonKeys.h
+++ b/mission/acs/str/arcsecJsonKeys.h
@ -176,13 +176,6 @@ static const char DEBUG_CAMERA[] = "DebugCamera";
 static const char TIMING[] = "timing";
 static const char TEST[] = "test";

-static constexpr char AUTO_THRESHOLD[] = "AutoThreshold";
-static constexpr char AT_MODE[] = "mode";
-static constexpr char AT_DESIRED_BLOB_COUNTS[] = "desiredBlobsCount";
-static constexpr char AT_MIN_THRESHOLD[] = "minThreshold";
-static constexpr char AT_MAX_THRESHOLD[] = "maxThreshold";
-static constexpr char AT_THRESHOLD_KP[] = "thresholdKp";
-
 }  // namespace arcseckeys

 #endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_ARCSECJSONKEYS_H_ */
--- a/mission/acs/str/strHelpers.h
+++ b/mission/acs/str/strHelpers.h
@ -326,8 +326,6 @@ static const DeviceCommandId_t DEBUG_CAMERA = 83;
 static const DeviceCommandId_t FIRMWARE_UPDATE = 84;
 static const DeviceCommandId_t DISABLE_TIMESTAMP_GENERATION = 85;
 static const DeviceCommandId_t ENABLE_TIMESTAMP_GENERATION = 86;
-static constexpr DeviceCommandId_t SET_TIME_FROM_SYS_TIME = 87;
-static constexpr DeviceCommandId_t AUTO_THRESHOLD = 88;
 static const DeviceCommandId_t NONE = 0xFFFFFFFF;

 static const uint32_t VERSION_SET_ID = REQ_VERSION;
@ -398,6 +396,7 @@ static const uint8_t ALGO = 16;
 static const uint8_t REBOOT = 7;
 static const uint8_t UPLOAD_IMAGE = 10;
 static const uint8_t POWER = 11;
+static const uint8_t SET_TIME = 14;
 static const uint8_t SUBSCRIPTION = 18;
 static const uint8_t SOLUTION = 24;
 static const uint8_t TEMPERATURE = 27;
@ -411,7 +410,6 @@ static const uint8_t TAKE_IMAGE = 15;
 static const uint8_t LOG_LEVEL = 3;
 static const uint8_t LOG_SUBSCRIPTION = 19;
 static const uint8_t DEBUG_CAMERA = 20;
-static const uint8_t AUTO_THRESHOLD = 23;
 }  // namespace ID

 namespace Program {
@ -443,21 +441,6 @@ static const uint32_t secret[16]{
    REGION_12_SECRET, REGION_13_SECRET, REGION_14_SECRET, REGION_15_SECRET};
 }  // namespace region_secrets

-namespace comError {
-enum Id {
-  BAD_CRC = 1,
-  UNKNOWN_TM_ID = 2,
-  UNKNOWN_PARAM_ID = 3,
-  UNKNOWN_ACTION_REQ = 4,
-  INVALID_TM_SIZE = 5,
-  INVALID_PARAM_SIZE = 6,
-  INVALID_ACTION_REQ_SIZE = 7,
-  FRAME_TOO_SHORT = 8,
-  INVALID_FRAME_TYPE = 9,
-  UNKNOWN_ERROR = 10
-};
-}
-
 enum class FlashSections : uint8_t {
  BOOTLOADER_SECTION = 0,
  MAIN_FIRMWARE_SECTION = 1,
@ -667,7 +650,7 @@ class SolutionSet : public StaticLocalDataSet<SOLUTION_SET_ENTRIES> {
  // Ticks timestamp
  lp_var_t<uint32_t> ticks = lp_var_t<uint32_t>(sid.objectId, PoolIds::TICKS_SOLUTION_SET, this);
  /// Unix time stamp
-  lp_var_t<uint64_t> timeUs = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_SOLUTION_SET, this);
+  lp_var_t<uint64_t> time = lp_var_t<uint64_t>(sid.objectId, PoolIds::TIME_SOLUTION_SET, this);
  // Calibrated quaternion (takes into account the mounting quaternion), typically same as
  // track q values
  lp_var_t<float> caliQw = lp_var_t<float>(sid.objectId, PoolIds::CALI_QW, this);
@ -712,7 +695,7 @@ class SolutionSet : public StaticLocalDataSet<SOLUTION_SET_ENTRIES> {
  void printSet() {
    PoolReadGuard rg(this);
    sif::info << "SolutionSet::printSet: Ticks: " << this->ticks << std::endl;
-    sif::info << "SolutionSet::printSet: Time: " << this->timeUs << std::endl;
+    sif::info << "SolutionSet::printSet: Time: " << this->time << std::endl;
    sif::info << "SolutionSet::printSet: Calibrated quaternion Qw: " << this->caliQw << std::endl;
    sif::info << "SolutionSet::printSet: Calibrated quaternion Qx: " << this->caliQx << std::endl;
    sif::info << "SolutionSet::printSet: Calibrated quaternion Qy: " << this->caliQy << std::endl;
--- a/mission/acs/str/strJsonCommands.cpp
+++ b/mission/acs/str/strJsonCommands.cpp
@ -916,45 +916,3 @@ ReturnValue_t DebugCamera::createCommand(uint8_t* buffer) {
  adduint32(param, buffer + offset);
  return returnvalue::OK;
 }
-
-AutoThreshold::AutoThreshold() : ArcsecJsonParamBase(arcseckeys::AUTO_THRESHOLD) {}
-
-size_t AutoThreshold::getSize() { return COMMAND_SIZE; }
-
-ReturnValue_t AutoThreshold::createCommand(uint8_t* buffer) {
-  ReturnValue_t result = returnvalue::OK;
-  uint8_t offset = 0;
-  std::string param;
-  addSetParamHeader(buffer, startracker::ID::AUTO_THRESHOLD);
-  offset = 2;
-  result = getParam(arcseckeys::AT_MODE, param);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  adduint8(param, buffer + offset);
-  offset += 1;
-  result = getParam(arcseckeys::AT_DESIRED_BLOB_COUNTS, param);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  adduint8(param, buffer + offset);
-  offset += 1;
-  result = getParam(arcseckeys::AT_MIN_THRESHOLD, param);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  adduint16(param, buffer + offset);
-  offset += 2;
-  result = getParam(arcseckeys::AT_MAX_THRESHOLD, param);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  adduint16(param, buffer + offset);
-  offset += 2;
-  result = getParam(arcseckeys::AT_THRESHOLD_KP, param);
-  if (result != returnvalue::OK) {
-    return result;
-  }
-  addfloat(param, buffer + offset);
-  return returnvalue::OK;
-}
--- a/mission/acs/str/strJsonCommands.h
+++ b/mission/acs/str/strJsonCommands.h
@ -222,22 +222,6 @@ class LogSubscription : public ArcsecJsonParamBase {
  ReturnValue_t createCommand(uint8_t* buffer) override;
 };

-/**
- * @brief   Generates command to set log subscription parameters.
- *
- */
-class AutoThreshold : public ArcsecJsonParamBase {
- public:
-  AutoThreshold();
-
-  size_t getSize();
-
- private:
-  static const size_t COMMAND_SIZE = 12;
-
-  ReturnValue_t createCommand(uint8_t* buffer) override;
-};
-
 /**
 * @brief   Generates command to set debug camera parameters
 *
--- a/mission/cfdp/CfdpHandler.cpp
+++ b/mission/cfdp/CfdpHandler.cpp
@ -93,8 +93,7 @@ ReturnValue_t CfdpHandler::handleCfdpPacket(TmTcMessage& msg) {
      return INVALID_PDU_FORMAT;
    }
    if (not FileDirectiveReader::checkFileDirective(pduDataField[0])) {
-      sif::error << "CfdpHandler: Invalid PDU directive field " << static_cast<int>(pduDataField[0])
-                 << std::endl;
+      sif::error << "CfdpHandler: Invalid PDU directive field " << pduDataField[0] << std::endl;
      return INVALID_DIRECTIVE_FIELD;
    }
    auto directive = static_cast<FileDirective>(pduDataField[0]);
--- a/mission/com/CcsdsIpCoreHandler.cpp
+++ b/mission/com/CcsdsIpCoreHandler.cpp
@ -246,13 +246,7 @@ ReturnValue_t CcsdsIpCoreHandler::checkModeCommand(Mode_t mode, Submode_t submod
 void CcsdsIpCoreHandler::startTransition(Mode_t mode, Submode_t submode) {
  triggerEvent(CHANGING_MODE, mode, submode);
  if (mode == HasModesIF::MODE_ON) {
-    uint32_t currentRate = ptmeConfig.getRate();
-    // Check whether the rate actually changes.
-    if ((this->submode != submode) and
-        (((submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_LOW) and
-           (currentRate != RATE_100KBPS))) or
-         ((submode == static_cast<Submode_t>(com::CcsdsSubmode::DATARATE_HIGH) and
-           (currentRate != RATE_500KBPS))))) {
+    if (this->submode != submode) {
      initPtmeUpdateAfterXCycles();
      updateContext.enableTransmitAfterPtmeUpdate = true;
      updateContext.updateClockRate = true;
--- a/mission/com/LiveTmTask.cpp
+++ b/mission/com/LiveTmTask.cpp
@ -19,8 +19,13 @@ LiveTmTask::LiveTmTask(object_id_t objectId, PusTmFunnel& pusFunnel, CfdpTmFunne
 ReturnValue_t LiveTmTask::performOperation(uint8_t opCode) {
  readCommandQueue();
  while (true) {
+    bool performWriteOp = true;
+    if (mode == MODE_OFF or ptmeLocked) {
+      performWriteOp = false;
+    }
+
    // The funnel tasks are scheduled here directly as well.
-    ReturnValue_t result = channel.handleNextTm(!ptmeLocked);
+    ReturnValue_t result = channel.handleNextTm(performWriteOp);
    if (result == DirectTmSinkIF::IS_BUSY) {
      sif::error << "Lost live TM, PAPB busy" << std::endl;
    }
--- a/mission/com/PersistentLogTmStoreTask.cpp
+++ b/mission/com/PersistentLogTmStoreTask.cpp
@ -42,7 +42,13 @@ ReturnValue_t PersistentLogTmStoreTask::performOperation(uint8_t opCode) {
    if (not someonesBusy) {
      TaskFactory::delayTask(100);
    } else if (vcBusyDuringDump) {
+      // TODO: Might not be necessary
+      sif::debug << "VC busy, delaying" << std::endl;
      TaskFactory::delayTask(10);
+    } else {
+      // TODO: Would be best to remove this, but not delaying here can lead to evil issues.
+      // Polling the PAPB of the PTME core too often leads to scheuduling issues.
+      TaskFactory::delayTask(2);
    }
  }
 }
--- a/mission/com/PersistentSingleTmStoreTask.cpp
+++ b/mission/com/PersistentSingleTmStoreTask.cpp
@ -24,7 +24,13 @@ ReturnValue_t PersistentSingleTmStoreTask::performOperation(uint8_t opCode) {
    if (not busy) {
      TaskFactory::delayTask(100);
    } else if (dumpContext.vcBusyDuringDump) {
+      sif::debug << "VC busy, delaying" << std::endl;
+      // TODO: Might not be necessary
      TaskFactory::delayTask(10);
+    } else {
+      // TODO: Would be best to remove this, but not delaying here can lead to evil issues.
+      // Polling the PAPB of the PTME core too often leads to scheuduling issues.
+      TaskFactory::delayTask(2);
    }
  }
 }
--- a/mission/com/SyrlinksHandler.cpp
+++ b/mission/com/SyrlinksHandler.cpp
@ -773,13 +773,11 @@ void SyrlinksHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
  auto txStandbyHandler = [&]() {
    txDataset.setReportingEnabled(false);
    poolManager.changeCollectionInterval(temperatureSet.getSid(), 60.0);
-    poolManager.changeCollectionInterval(rxDataset.getSid(), 60.0);
    transState = TransitionState::SET_TX_STANDBY;
    internalState = InternalState::TX_TRANSITION;
  };
  auto txOnHandler = [&](TransitionState tgtTransitionState) {
    txDataset.setReportingEnabled(true);
-    poolManager.changeCollectionInterval(rxDataset.getSid(), 5.0);
    poolManager.changeCollectionInterval(txDataset.getSid(), 10.0);
    poolManager.changeCollectionInterval(temperatureSet.getSid(), 5.0);
    transState = tgtTransitionState;
--- a/mission/com/TmStoreTaskBase.cpp
+++ b/mission/com/TmStoreTaskBase.cpp
@ -45,19 +45,13 @@ bool TmStoreTaskBase::handleOneStore(PersistentTmStoreWithTmQueue& store,
  } else {
    Command_t execCmd;
    // Handle TC requests, for example deletion or retrieval requests.
-    // TODO: Not really clean here.. would be better if the executed command is returns as an
-    // enumeration.
    result = store.handleCommandQueue(ipcStore, execCmd);
-    if (execCmd == TmStoreMessage::DOWNLINK_STORE_CONTENT_TIME) {
-      if (result == PersistentTmStore::DUMP_DONE) {
-        dumpDoneHandler(store, dumpContext);
-      } else if (result == returnvalue::OK) {
+    if (result == returnvalue::OK) {
+      if (execCmd == TmStoreMessage::DOWNLINK_STORE_CONTENT_TIME) {
        cancelDumpCd.resetTimer();
        tmSinkBusyCd.resetTimer();
        dumpContext.reset();
      }
-    }
-    if (execCmd != CommandMessageIF::CMD_NONE) {
      tcRequestReceived = true;
    }
  }
@ -125,13 +119,21 @@ ReturnValue_t TmStoreTaskBase::performDump(PersistentTmStoreWithTmQueue& store,
                                           DumpContext& dumpContext, bool& dumpPerformed) {
  size_t dumpedLen = 0;

+  auto dumpDoneHandler = [&]() {
+    uint32_t startTime;
+    uint32_t endTime;
+    store.getStartAndEndTimeCurrentOrLastDump(startTime, endTime);
+    triggerEvent(dumpContext.eventIfDone, dumpContext.numberOfDumpedPackets,
+                 dumpContext.dumpedBytes);
+    dumpContext.reset();
+  };
  // Dump the next packet into the PTME.
  dumpContext.ptmeBusyCounter = 0;
  tmSinkBusyCd.resetTimer();
  ReturnValue_t result = store.getNextDumpPacket(tmReader, fileHasSwapped);
  if (fileHasSwapped and result == PersistentTmStore::DUMP_DONE) {
    // This can happen if a file is corrupted and the next file swap completes the dump.
-    dumpDoneHandler(store, dumpContext);
+    dumpDoneHandler();
    return returnvalue::OK;
  } else if (result != returnvalue::OK) {
    sif::error << "PersistentTmStore: Getting next dump packet failed" << std::endl;
@ -155,7 +157,7 @@ ReturnValue_t TmStoreTaskBase::performDump(PersistentTmStoreWithTmQueue& store,
    }
  }
  if (result == PersistentTmStore::DUMP_DONE) {
-    dumpDoneHandler(store, dumpContext);
+    dumpDoneHandler();
  }
  return returnvalue::OK;
 }
@ -196,14 +198,6 @@ ReturnValue_t TmStoreTaskBase::connectModeTreeParent(HasModeTreeChildrenIF& pare
  return modetree::connectModeTreeParent(parent, *this, nullptr, modeHelper);
 }

-void TmStoreTaskBase::dumpDoneHandler(PersistentTmStore& store, DumpContext& dumpContext) {
-  uint32_t startTime;
-  uint32_t endTime;
-  store.getStartAndEndTimeCurrentOrLastDump(startTime, endTime);
-  triggerEvent(dumpContext.eventIfDone, dumpContext.numberOfDumpedPackets, dumpContext.dumpedBytes);
-  dumpContext.reset();
-}
-
 ModeTreeChildIF& TmStoreTaskBase::getModeTreeChildIF() { return *this; }

 void TmStoreTaskBase::readCommandQueue(void) {
--- a/mission/com/TmStoreTaskBase.h
+++ b/mission/com/TmStoreTaskBase.h
@ -96,8 +96,6 @@ class TmStoreTaskBase : public SystemObject,

  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
                                 uint32_t* msToReachTheMode) override;
-  void dumpDoneHandler(PersistentTmStore& store, DumpContext& dumpContext);
-
  void announceMode(bool recursive) override;
  object_id_t getObjectId() const override;
  const HasHealthIF* getOptHealthIF() const override;
--- a/mission/controller/AcsController.cpp
+++ b/mission/controller/AcsController.cpp
@ -7,7 +7,6 @@
 AcsController::AcsController(object_id_t objectId, bool enableHkSets)
    : ExtendedControllerBase(objectId),
      enableHkSets(enableHkSets),
-      fusedRotationEstimation(&acsParameters),
      guidance(&acsParameters),
      safeCtrl(&acsParameters),
      ptgCtrl(&acsParameters),
@ -21,8 +20,7 @@ AcsController::AcsController(object_id_t objectId, bool enableHkSets)
      gpsDataProcessed(this),
      mekfData(this),
      ctrlValData(this),
-      actuatorCmdData(this),
-      fusedRotRateData(this) {}
+      actuatorCmdData(this) {}

 ReturnValue_t AcsController::initialize() {
  ReturnValue_t result = parameterHelper.initialize();
@ -148,8 +146,6 @@ void AcsController::performSafe() {

  sensorProcessing.process(now, &sensorValues, &mgmDataProcessed, &susDataProcessed,
                           &gyrDataProcessed, &gpsDataProcessed, &acsParameters);
-  fusedRotationEstimation.estimateFusedRotationRateSafe(&susDataProcessed, &mgmDataProcessed,
-                                                        &gyrDataProcessed, &fusedRotRateData);
  ReturnValue_t result = navigation.useMekf(&sensorValues, &gyrDataProcessed, &mgmDataProcessed,
                                            &susDataProcessed, &mekfData, &acsParameters);
  if (result != MultiplicativeKalmanFilter::MEKF_RUNNING &&
@ -176,42 +172,25 @@ void AcsController::performSafe() {
  acs::SafeModeStrategy safeCtrlStrat = safeCtrl.safeCtrlStrategy(
      mgmDataProcessed.mgmVecTot.isValid(), not mekfInvalidFlag,
      gyrDataProcessed.gyrVecTot.isValid(), susDataProcessed.susVecTot.isValid(),
-      fusedRotRateData.rotRateOrthogonal.isValid(), fusedRotRateData.rotRateTotal.isValid(),
      acsParameters.safeModeControllerParameters.useMekf,
-      acsParameters.safeModeControllerParameters.useGyr,
      acsParameters.safeModeControllerParameters.dampingDuringEclipse);
  switch (safeCtrlStrat) {
-    case (acs::SafeModeStrategy::SAFECTRL_MEKF):
+    case (acs::SafeModeStrategy::SAFECTRL_ACTIVE_MEKF):
      safeCtrl.safeMekf(mgmDataProcessed.mgmVecTot.value, mekfData.satRotRateMekf.value,
                        susDataProcessed.sunIjkModel.value, mekfData.quatMekf.value, sunTargetDir,
                        magMomMtq, errAng);
      safeCtrlFailureFlag = false;
      safeCtrlFailureCounter = 0;
      break;
-    case (acs::SafeModeStrategy::SAFECTRL_GYR):
-      safeCtrl.safeGyr(mgmDataProcessed.mgmVecTot.value, gyrDataProcessed.gyrVecTot.value,
-                       susDataProcessed.susVecTot.value, sunTargetDir, magMomMtq, errAng);
+    case (acs::SafeModeStrategy::SAFECTRL_WITHOUT_MEKF):
+      safeCtrl.safeNonMekf(mgmDataProcessed.mgmVecTot.value, gyrDataProcessed.gyrVecTot.value,
+                           susDataProcessed.susVecTot.value, sunTargetDir, magMomMtq, errAng);
      safeCtrlFailureFlag = false;
      safeCtrlFailureCounter = 0;
      break;
-    case (acs::SafeModeStrategy::SAFECTRL_SUSMGM):
-      safeCtrl.safeSusMgm(mgmDataProcessed.mgmVecTot.value, fusedRotRateData.rotRateParallel.value,
-                          fusedRotRateData.rotRateOrthogonal.value,
-                          susDataProcessed.susVecTot.value, sunTargetDir, magMomMtq, errAng);
-      safeCtrlFailureFlag = false;
-      safeCtrlFailureCounter = 0;
-      break;
-    case (acs::SafeModeStrategy::SAFECTRL_ECLIPSE_DAMPING_GYR):
-      safeCtrl.safeRateDampingGyr(mgmDataProcessed.mgmVecTot.value,
-                                  gyrDataProcessed.gyrVecTot.value, sunTargetDir, magMomMtq,
-                                  errAng);
-      safeCtrlFailureFlag = false;
-      safeCtrlFailureCounter = 0;
-      break;
-    case (acs::SafeModeStrategy::SAFECTRL_ECLIPSE_DAMPING_SUSMGM):
-      safeCtrl.safeRateDampingSusMgm(mgmDataProcessed.mgmVecTot.value,
-                                     fusedRotRateData.rotRateTotal.value, sunTargetDir, magMomMtq,
-                                     errAng);
+    case (acs::SafeModeStrategy::SAFECTRL_ECLIPSE_DAMPING):
+      safeCtrl.safeRateDamping(mgmDataProcessed.mgmVecTot.value, gyrDataProcessed.gyrVecTot.value,
+                               sunTargetDir, magMomMtq, errAng);
      safeCtrlFailureFlag = false;
      safeCtrlFailureCounter = 0;
      break;
@ -235,20 +214,12 @@ void AcsController::performSafe() {
                           acsParameters.magnetorquerParameter.dipoleMax, magMomMtq, cmdDipoleMtqs);

  // detumble check and switch
-  if (acsParameters.safeModeControllerParameters.useMekf) {
-    if (mekfData.satRotRateMekf.isValid() and
-        VectorOperations<double>::norm(mekfData.satRotRateMekf.value, 3) >
-            acsParameters.detumbleParameter.omegaDetumbleStart) {
-      detumbleCounter++;
-    }
-  } else if (acsParameters.safeModeControllerParameters.useGyr) {
-    if (gyrDataProcessed.gyrVecTot.isValid() and
-        VectorOperations<double>::norm(gyrDataProcessed.gyrVecTot.value, 3) >
-            acsParameters.detumbleParameter.omegaDetumbleStart) {
-      detumbleCounter++;
-    }
-  } else if (fusedRotRateData.rotRateTotal.isValid() and
-             VectorOperations<double>::norm(fusedRotRateData.rotRateTotal.value, 3) >
+  if (mekfData.satRotRateMekf.isValid() && acsParameters.safeModeControllerParameters.useMekf &&
+      VectorOperations<double>::norm(mekfData.satRotRateMekf.value, 3) >
+          acsParameters.detumbleParameter.omegaDetumbleStart) {
+    detumbleCounter++;
+  } else if (gyrDataProcessed.gyrVecTot.isValid() &&
+             VectorOperations<double>::norm(gyrDataProcessed.gyrVecTot.value, 3) >
                 acsParameters.detumbleParameter.omegaDetumbleStart) {
    detumbleCounter++;
  } else if (detumbleCounter > 0) {
@ -318,26 +289,17 @@ void AcsController::performDetumble() {
  actuatorCmd.cmdDipoleMtq(*acsParameters.magnetorquerParameter.inverseAlignment,
                           acsParameters.magnetorquerParameter.dipoleMax, magMomMtq, cmdDipoleMtqs);

-  if (acsParameters.safeModeControllerParameters.useMekf) {
-    if (mekfData.satRotRateMekf.isValid() and
-        VectorOperations<double>::norm(mekfData.satRotRateMekf.value, 3) <
-            acsParameters.detumbleParameter.omegaDetumbleStart) {
-      detumbleCounter++;
-    }
-  } else if (acsParameters.safeModeControllerParameters.useGyr) {
-    if (gyrDataProcessed.gyrVecTot.isValid() and
-        VectorOperations<double>::norm(gyrDataProcessed.gyrVecTot.value, 3) <
-            acsParameters.detumbleParameter.omegaDetumbleStart) {
-      detumbleCounter++;
-    }
-  } else if (fusedRotRateData.rotRateTotal.isValid() and
-             VectorOperations<double>::norm(fusedRotRateData.rotRateTotal.value, 3) <
-                 acsParameters.detumbleParameter.omegaDetumbleStart) {
+  if (mekfData.satRotRateMekf.isValid() &&
+      VectorOperations<double>::norm(mekfData.satRotRateMekf.value, 3) <
+          acsParameters.detumbleParameter.omegaDetumbleEnd) {
+    detumbleCounter++;
+  } else if (gyrDataProcessed.gyrVecTot.isValid() &&
+             VectorOperations<double>::norm(gyrDataProcessed.gyrVecTot.value, 3) <
+                 acsParameters.detumbleParameter.omegaDetumbleEnd) {
    detumbleCounter++;
  } else if (detumbleCounter > 0) {
    detumbleCounter -= 1;
  }
-
  if (detumbleCounter > acsParameters.detumbleParameter.detumblecounter) {
    detumbleCounter = 0;
    // Triggers safe mode transition in subsystem
@ -745,11 +707,6 @@ ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localD
  localDataPoolMap.emplace(acsctrl::PoolIds::RW_TARGET_SPEED, &rwTargetSpeed);
  localDataPoolMap.emplace(acsctrl::PoolIds::MTQ_TARGET_DIPOLE, &mtqTargetDipole);
  poolManager.subscribeForRegularPeriodicPacket({actuatorCmdData.getSid(), enableHkSets, 10.0});
-  // Fused Rot Rate
-  localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_ORTHOGONAL, &rotRateOrthogonal);
-  localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_PARALLEL, &rotRateParallel);
-  localDataPoolMap.emplace(acsctrl::PoolIds::ROT_RATE_TOTAL, &rotRateTotal);
-  poolManager.subscribeForRegularPeriodicPacket({fusedRotRateData.getSid(), enableHkSets, 10.0});
  return returnvalue::OK;
 }

@ -775,8 +732,6 @@ LocalPoolDataSetBase *AcsController::getDataSetHandle(sid_t sid) {
      return &ctrlValData;
    case acsctrl::ACTUATOR_CMD_DATA:
      return &actuatorCmdData;
-    case acsctrl::FUSED_ROTATION_RATE_DATA:
-      return &fusedRotRateData;
    default:
      return nullptr;
  }
--- a/mission/controller/AcsController.h
+++ b/mission/controller/AcsController.h
@ -13,7 +13,6 @@
 #include <mission/acs/rwHelpers.h>
 #include <mission/acs/susMax1227Helpers.h>
 #include <mission/controller/acs/ActuatorCmd.h>
-#include <mission/controller/acs/FusedRotationEstimation.h>
 #include <mission/controller/acs/Guidance.h>
 #include <mission/controller/acs/MultiplicativeKalmanFilter.h>
 #include <mission/controller/acs/Navigation.h>
@ -50,7 +49,6 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes

  AcsParameters acsParameters;
  SensorProcessing sensorProcessing;
-  FusedRotationEstimation fusedRotationEstimation;
  Navigation navigation;
  ActuatorCmd actuatorCmd;
  Guidance guidance;
@ -228,12 +226,6 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
  PoolEntry<int32_t> rwTargetSpeed = PoolEntry<int32_t>(4);
  PoolEntry<int16_t> mtqTargetDipole = PoolEntry<int16_t>(3);

-  // Fused Rot Rate
-  acsctrl::FusedRotRateData fusedRotRateData;
-  PoolEntry<double> rotRateOrthogonal = PoolEntry<double>(3);
-  PoolEntry<double> rotRateParallel = PoolEntry<double>(3);
-  PoolEntry<double> rotRateTotal = PoolEntry<double>(3);
-
  // Initial delay to make sure all pool variables have been initialized their owners
  Countdown initialCountdown = Countdown(INIT_DELAY);
 };
--- a/mission/controller/ThermalController.cpp
+++ b/mission/controller/ThermalController.cpp
--- a/mission/controller/ThermalController.h
+++ b/mission/controller/ThermalController.h
@ -1,7 +1,7 @@
 #ifndef MISSION_CONTROLLER_THERMALCONTROLLER_H_
 #define MISSION_CONTROLLER_THERMALCONTROLLER_H_

-#include <bsp_q7s/core/defs.h>
+#include <bsp_q7s/core/CoreDefinitions.h>
 #include <fsfw/controller/ExtendedControllerBase.h>
 #include <fsfw/devicehandlers/DeviceHandlerThermalSet.h>
 #include <fsfw/timemanager/Countdown.h>
@ -24,7 +24,74 @@

 #include <atomic>
 #include <list>
-#include <optional>
+
+/**
+ * NOP Limit: Hard limit for device, usually from datasheet. Device damage is possible lif NOP limit
+ * is exceeded.
+ * OP Limit: Soft limit. Device should be switched off or TCS controller should take action if the
+ * limit is exceeded to avoid reaching NOP limit
+ */
+struct TempLimits {
+  TempLimits(float nopLowerLimit, float opLowerLimit, float cutOffLimit, float opUpperLimit,
+             float nopUpperLimit)
+      : opLowerLimit(opLowerLimit),
+        opUpperLimit(opUpperLimit),
+        cutOffLimit(cutOffLimit),
+        nopLowerLimit(nopLowerLimit),
+        nopUpperLimit(nopUpperLimit) {}
+  float opLowerLimit;
+  float opUpperLimit;
+  float cutOffLimit;
+  float nopLowerLimit;
+  float nopUpperLimit;
+};
+
+struct ThermalState {
+  uint8_t errorCounter;
+  // Is heating on for that thermal module?
+  bool heating = false;
+  heater::Switch heaterSwitch = heater::Switch::NUMBER_OF_SWITCHES;
+  // Heater start time and end times as UNIX seconds. Please note that these times will be updated
+  // when a switch command is sent, with no guarantess that the heater actually went on.
+  uint32_t heaterStartTime = 0;
+  uint32_t heaterEndTime = 0;
+};
+
+struct HeaterState {
+  bool switchTransition;
+  HeaterHandler::SwitchState target;
+  uint8_t heaterSwitchControlCycles;
+};
+
+using HeaterSwitchStates = std::array<HeaterHandler::SwitchState, heater::NUMBER_OF_SWITCHES>;
+
+enum ThermalComponents : uint8_t {
+  NONE = 0,
+  ACS_BOARD = 1,
+  MGT = 2,
+  RW = 3,
+  STR = 4,
+  IF_BOARD = 5,
+  TCS_BOARD = 6,
+  OBC = 7,
+  OBCIF_BOARD = 8,
+  SBAND_TRANSCEIVER = 9,
+  PCDUP60_BOARD = 10,
+  PCDUACU = 11,
+  PCDUPDU = 12,
+  PLPCDU_BOARD = 13,
+  PLOCMISSION_BOARD = 14,
+  PLOCPROCESSING_BOARD = 15,
+  DAC = 16,
+  CAMERA = 17,
+  DRO = 18,
+  X8 = 19,
+  HPA = 20,
+  TX = 21,
+  MPA = 22,
+  SCEX_BOARD = 23,
+  NUM_ENTRIES
+};

 class ThermalController : public ExtendedControllerBase {
 public:
@ -35,28 +102,8 @@ class ThermalController : public ExtendedControllerBase {
  static constexpr int16_t SANITY_LIMIT_LOWER_TEMP = -80;
  static constexpr int16_t SANITY_LIMIT_UPPER_TEMP = 160;

-  // 1 hour
-  static constexpr uint32_t DEFAULT_MAX_HEATER_ON_DURATION_MS = 60 * 60 * 1000;
-  static constexpr uint32_t MAX_HEATER_ON_DURATIONS_MS[8] = {// PLOC PROC board
-                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
-                                                             // PCDU PDU
-                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
-                                                             // ACS Board
-                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
-                                                             // OBC Board
-                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
-                                                             // Camera
-                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
-                                                             // STR
-                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
-                                                             // DRO
-                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS,
-                                                             // S-Band
-                                                             DEFAULT_MAX_HEATER_ON_DURATION_MS};
-
  ThermalController(object_id_t objectId, HeaterHandler& heater,
-                    const std::atomic_bool& tcsBoardShortUnavailable, bool pollPcdu1Tmp);
-  virtual ~ThermalController();
+                    const std::atomic_bool& tcsBoardShortUnavailable);

  ReturnValue_t initialize() override;

@ -64,16 +111,16 @@ class ThermalController : public ExtendedControllerBase {
  struct HeaterContext {
   public:
    HeaterContext(heater::Switch switchNr, heater::Switch redundantSwitchNr,
-                  const tcsCtrl::TempLimits& tempLimit)
+                  const TempLimits& tempLimit)
        : switchNr(switchNr), redSwitchNr(redundantSwitchNr), tempLimit(tempLimit) {}
    bool doHeaterHandling = true;
    heater::Switch switchNr;
-    heater::SwitchState switchState = heater::SwitchState::OFF;
+    HeaterHandler::SwitchState switchState = HeaterHandler::SwitchState::OFF;
    heater::Switch redSwitchNr;
-    const tcsCtrl::TempLimits& tempLimit;
+    const TempLimits& tempLimit;
  };

-  void performThermalModuleCtrl(const tcsCtrl::HeaterSwitchStates& heaterSwitchStates);
+  void performThermalModuleCtrl(const HeaterSwitchStates& heaterSwitchStates);
  ReturnValue_t handleCommandMessage(CommandMessage* message) override;
  void performControlOperation() override;
  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
@ -95,12 +142,12 @@ class ThermalController : public ExtendedControllerBase {

  HeaterHandler& heaterHandler;

-  bool pollPcdu1Tmp;
  tcsCtrl::SensorTemperatures sensorTemperatures;
  tcsCtrl::SusTemperatures susTemperatures;
  tcsCtrl::DeviceTemperatures deviceTemperatures;
  tcsCtrl::HeaterInfo heaterInfo;
-  tcsCtrl::TcsCtrlInfo tcsCtrlInfo;
+  lp_vec_t<int16_t, 9> currentVecPdu2 =
+      lp_vec_t<int16_t, 9>(gp_id_t(objects::PDU2_HANDLER, PDU::pool::PDU_CURRENTS));

  DeviceHandlerThermalSet imtqThermalSet;

@ -126,7 +173,7 @@ class ThermalController : public ExtendedControllerBase {
  TMP1075::Tmp1075Dataset tmp1075SetTcs1;
  TMP1075::Tmp1075Dataset tmp1075SetPlPcdu0;
  // damaged
-  TMP1075::Tmp1075Dataset* tmp1075SetPlPcdu1;
+  // TMP1075::Tmp1075Dataset tmp1075SetPlPcdu1;
  TMP1075::Tmp1075Dataset tmp1075SetIfBoard;

  // SUS
@ -180,67 +227,57 @@ class ThermalController : public ExtendedControllerBase {
  lp_var_t<float> tempMgm2 =
      lp_var_t<float>(objects::MGM_2_LIS3_HANDLER, mgmLis3::TEMPERATURE_CELCIUS);
  lp_var_t<float> tempAdcPayloadPcdu = lp_var_t<float>(objects::PLPCDU_HANDLER, plpcdu::TEMP);
-  lp_vec_t<int16_t, 9> currentVecPdu2 =
-      lp_vec_t<int16_t, 9>(gp_id_t(objects::PDU2_HANDLER, PDU::pool::PDU_CURRENTS));

  // TempLimits
-  tcsCtrl::TempLimits acsBoardLimits = tcsCtrl::TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
-  tcsCtrl::TempLimits mgtLimits = tcsCtrl::TempLimits(-40.0, -40.0, 65.0, 70.0, 70.0);
-  tcsCtrl::TempLimits rwLimits = tcsCtrl::TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
-  tcsCtrl::TempLimits strLimits = tcsCtrl::TempLimits(-30.0, -20.0, 65.0, 70.0, 80.0);
-  tcsCtrl::TempLimits ifBoardLimits = tcsCtrl::TempLimits(-65.0, -40.0, 80.0, 85.0, 150.0);
-  tcsCtrl::TempLimits tcsBoardLimits = tcsCtrl::TempLimits(-60.0, -40.0, 80.0, 85.0, 130.0);
-  tcsCtrl::TempLimits obcLimits = tcsCtrl::TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
-  tcsCtrl::TempLimits obcIfBoardLimits = tcsCtrl::TempLimits(-65.0, -40.0, 80.0, 85.0, 125.0);
-  tcsCtrl::TempLimits sBandTransceiverLimits = tcsCtrl::TempLimits(-40.0, -25.0, 35.0, 40.0, 65.0);
-  tcsCtrl::TempLimits pcduP60BoardLimits = tcsCtrl::TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
-  tcsCtrl::TempLimits pcduAcuLimits = tcsCtrl::TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
-  tcsCtrl::TempLimits pcduPduLimits = tcsCtrl::TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
-  tcsCtrl::TempLimits plPcduBoardLimits = tcsCtrl::TempLimits(-55.0, -40.0, 80.0, 85.0, 125.0);
-  tcsCtrl::TempLimits plocMissionBoardLimits = tcsCtrl::TempLimits(-30.0, -10.0, 40.0, 45.0, 60);
-  tcsCtrl::TempLimits plocProcessingBoardLimits =
-      tcsCtrl::TempLimits(-30.0, -10.0, 40.0, 45.0, 60.0);
-  tcsCtrl::TempLimits dacLimits = tcsCtrl::TempLimits(-65.0, -40.0, 113.0, 118.0, 150.0);
-  tcsCtrl::TempLimits cameraLimits = tcsCtrl::TempLimits(-40.0, -30.0, 60.0, 65.0, 85.0);
-  tcsCtrl::TempLimits droLimits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
-  tcsCtrl::TempLimits x8Limits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
-  tcsCtrl::TempLimits hpaLimits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
-  tcsCtrl::TempLimits txLimits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
-  tcsCtrl::TempLimits mpaLimits = tcsCtrl::TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
-  tcsCtrl::TempLimits scexBoardLimits = tcsCtrl::TempLimits(-60.0, -40.0, 80.0, 85.0, 150.0);
-
-  struct CtrlContext {
-    double sensorTemp = INVALID_TEMPERATURE;
-    uint8_t currentSensorIndex = 0;
-    tcsCtrl::ThermalComponents thermalComponent = tcsCtrl::NONE;
-    bool redSwitchNrInUse = false;
-    bool componentAboveCutOffLimit = false;
-    bool componentAboveUpperLimit = false;
-    Event overHeatEventToTrigger;
-  } ctrlCtx;
+  TempLimits acsBoardLimits = TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
+  TempLimits mgtLimits = TempLimits(-40.0, -40.0, 65.0, 70.0, 70.0);
+  TempLimits rwLimits = TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
+  TempLimits strLimits = TempLimits(-30.0, -20.0, 65.0, 70.0, 80.0);
+  TempLimits ifBoardLimits = TempLimits(-65.0, -40.0, 80.0, 85.0, 150.0);
+  TempLimits tcsBoardLimits = TempLimits(-60.0, -40.0, 80.0, 85.0, 130.0);
+  TempLimits obcLimits = TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);
+  TempLimits obcIfBoardLimits = TempLimits(-65.0, -40.0, 80.0, 85.0, 125.0);
+  TempLimits sBandTransceiverLimits = TempLimits(-40.0, -25.0, 35.0, 40.0, 65.0);
+  TempLimits pcduP60BoardLimits = TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
+  TempLimits pcduAcuLimits = TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
+  TempLimits pcduPduLimits = TempLimits(-35.0, -35.0, 80.0, 85.0, 85.0);
+  TempLimits plPcduBoardLimits = TempLimits(-55.0, -40.0, 80.0, 85.0, 125.0);
+  TempLimits plocMissionBoardLimits = TempLimits(-30.0, -10.0, 40.0, 45.0, 60);
+  TempLimits plocProcessingBoardLimits = TempLimits(-30.0, -10.0, 40.0, 45.0, 60.0);
+  TempLimits dacLimits = TempLimits(-65.0, -40.0, 113.0, 118.0, 150.0);
+  TempLimits cameraLimits = TempLimits(-40.0, -30.0, 60.0, 65.0, 85.0);
+  TempLimits droLimits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
+  TempLimits x8Limits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
+  TempLimits hpaLimits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
+  TempLimits txLimits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
+  TempLimits mpaLimits = TempLimits(-40.0, -30.0, 75.0, 80.0, 90.0);
+  TempLimits scexBoardLimits = TempLimits(-60.0, -40.0, 80.0, 85.0, 150.0);

+  double sensorTemp = INVALID_TEMPERATURE;
+  ThermalComponents thermalComponent = NONE;
+  bool redSwitchNrInUse = false;
  MessageQueueId_t camId = MessageQueueIF::NO_QUEUE;
-
-  struct TooHotFlags {
-    bool eBandTooHotFlag = false;
-    bool camTooHotOneShotFlag = false;
-    bool scexTooHotFlag = false;
-    bool plocTooHotFlag = false;
-    bool pcduSystemTooHotFlag = false;
-    bool syrlinksTooHotFlag = false;
-    bool obcTooHotFlag = false;
-    bool mgtTooHotFlag = false;
-    bool strTooHotFlag = false;
-    bool rwTooHotFlag = false;
-  } tooHotFlags;
+  bool componentAboveCutOffLimit = false;
+  bool componentAboveUpperLimit = false;
+  Event overHeatEventToTrigger;
+  bool eBandTooHotFlag = false;
+  bool camTooHotOneShotFlag = false;
+  bool scexTooHotFlag = false;
+  bool plocTooHotFlag = false;
+  bool pcduSystemTooHotFlag = false;
+  bool syrlinksTooHotFlag = false;
+  bool obcTooHotFlag = false;
+  bool mgtTooHotFlag = false;
+  bool strTooHotFlag = false;
+  bool rwTooHotFlag = false;

  bool transitionWhenHeatersOff = false;
  uint32_t transitionWhenHeatersOffCycles = 0;
  Mode_t targetMode = MODE_OFF;
  Submode_t targetSubmode = SUBMODE_NONE;
  uint32_t cycles = 0;
-  std::array<tcsCtrl::ThermalState, tcsCtrl::NUM_THERMAL_COMPONENTS> thermalStates{};
-  std::array<tcsCtrl::HeaterState, heater::NUMBER_OF_SWITCHES> heaterStates{};
+  std::array<ThermalState, ThermalComponents::NUM_ENTRIES> thermalStates{};
+  std::array<HeaterState, heater::NUMBER_OF_SWITCHES> heaterStates{};

  // Initial delay to make sure all pool variables have been initialized their owners.
  // Also, wait for system initialization to complete.
@ -261,12 +298,6 @@ class ThermalController : public ExtendedControllerBase {
  PoolEntry<uint8_t> heaterSwitchStates = PoolEntry<uint8_t>(heater::NUMBER_OF_SWITCHES);
  PoolEntry<int16_t> heaterCurrent = PoolEntry<int16_t>();

-  PoolEntry<uint8_t> tcsCtrlHeaterOn = PoolEntry<uint8_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
-  PoolEntry<uint8_t> tcsCtrlSensorIdx = PoolEntry<uint8_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
-  PoolEntry<uint8_t> tcsCtrlHeaterIdx = PoolEntry<uint8_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
-  PoolEntry<uint32_t> tcsCtrlStartTimes = PoolEntry<uint32_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
-  PoolEntry<uint32_t> tcsCtrlEndTimes = PoolEntry<uint32_t>(tcsCtrl::NUM_THERMAL_COMPONENTS);
-
  static constexpr dur_millis_t MUTEX_TIMEOUT = 50;

  void startTransition(Mode_t mode, Submode_t submode) override;
@ -288,8 +319,8 @@ class ThermalController : public ExtendedControllerBase {
  bool selectAndReadSensorTemp(HeaterContext& htrCtx);

  void heaterSwitchHelperAllOff();
-  void heaterSwitchHelper(heater::Switch switchNr, heater::SwitchState state,
-                          std::optional<unsigned> componentIdx);
+  void heaterSwitchHelper(heater::Switch switchNr, HeaterHandler::SwitchState state,
+                          unsigned componentIdx);

  void ctrlAcsBoard();
  void ctrlMgt();
@ -298,6 +329,7 @@ class ThermalController : public ExtendedControllerBase {
  void ctrlIfBoard();
  void ctrlTcsBoard();
  void ctrlObc();
+  void ctrlObcIfBoard();
  void ctrlSBandTransceiver();
  void ctrlPcduP60Board();
  void ctrlPcduAcu();
@ -313,22 +345,7 @@ class ThermalController : public ExtendedControllerBase {
  void ctrlTx();
  void ctrlMpa();
  void ctrlScexBoard();
-
-  /**
-   * The transition of heaters might take some time. As long as a transition is
-   * going on, the TCS controller works in a reduced form. This function takes care
-   * of tracking transition and capturing their completion.
-   * @param currentHeaterStates
-   */
-  void heaterTransitionControl(const tcsCtrl::HeaterSwitchStates& currentHeaterStates);
-  /**
-   * Control tasks to prevent heaters being on for prolonged periods. Ideally, this
-   * should never happen, but this task prevents bugs from causing heaters to stay on
-   * for a long time, which draws a lot of power.
-   * @param currentHeaterStates
-   */
-  void heaterMaxDurationControl(const tcsCtrl::HeaterSwitchStates& currentHeaterStates);
-  void crossCheckHeaterStateOfComponentsWhenHeaterGoesOff(heater::Switch switchIdx);
+  void heaterTransitionControl(const HeaterSwitchStates& currentHeaterStates);
  void setMode(Mode_t mode, Submode_t submode);
  uint32_t tempFloatToU32() const;
  bool tooHotHandler(object_id_t object, bool& oneShotFlag);
--- a/mission/controller/acs/AcsParameters.cpp
+++ b/mission/controller/acs/AcsParameters.cpp
@ -105,9 +105,6 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
          parameterWrapper->setVector(mgmHandlingParameters.mgm4variance);
          break;
        case 0x12:
-          parameterWrapper->set(mgmHandlingParameters.mgmVectorFilterWeight);
-          break;
-        case 0x13:
          parameterWrapper->set(mgmHandlingParameters.mgmDerivativeFilterWeight);
          break;
        default:
@ -227,12 +224,6 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
        case 0x24:
          parameterWrapper->set(susHandlingParameters.susBrightnessThreshold);
          break;
-        case 0x25:
-          parameterWrapper->set(susHandlingParameters.susVectorFilterWeight);
-          break;
-        case 0x26:
-          parameterWrapper->set(susHandlingParameters.susRateFilterWeight);
-          break;
        default:
          return INVALID_IDENTIFIER_ID;
      }
@ -348,41 +339,26 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
          parameterWrapper->set(safeModeControllerParameters.k_parallelMekf);
          break;
        case 0x3:
-          parameterWrapper->set(safeModeControllerParameters.k_orthoGyr);
+          parameterWrapper->set(safeModeControllerParameters.k_orthoNonMekf);
          break;
        case 0x4:
-          parameterWrapper->set(safeModeControllerParameters.k_alignGyr);
+          parameterWrapper->set(safeModeControllerParameters.k_alignNonMekf);
          break;
        case 0x5:
-          parameterWrapper->set(safeModeControllerParameters.k_parallelGyr);
+          parameterWrapper->set(safeModeControllerParameters.k_parallelNonMekf);
          break;
        case 0x6:
-          parameterWrapper->set(safeModeControllerParameters.k_orthoSusMgm);
-          break;
-        case 0x7:
-          parameterWrapper->set(safeModeControllerParameters.k_alignSusMgm);
-          break;
-        case 0x8:
-          parameterWrapper->set(safeModeControllerParameters.k_parallelSusMgm);
-          break;
-        case 0x9:
          parameterWrapper->setVector(safeModeControllerParameters.sunTargetDirLeop);
          break;
-        case 0xA:
+        case 0x7:
          parameterWrapper->setVector(safeModeControllerParameters.sunTargetDir);
          break;
-        case 0xB:
+        case 0x8:
          parameterWrapper->set(safeModeControllerParameters.useMekf);
          break;
-        case 0xC:
-          parameterWrapper->set(safeModeControllerParameters.useGyr);
-          break;
-        case 0xD:
+        case 0x9:
          parameterWrapper->set(safeModeControllerParameters.dampingDuringEclipse);
          break;
-        case 0xE:
-          parameterWrapper->set(safeModeControllerParameters.sineLimitSunRotRate);
-          break;
        default:
          return INVALID_IDENTIFIER_ID;
      }
--- a/mission/controller/acs/AcsParameters.h
+++ b/mission/controller/acs/AcsParameters.h
@ -77,8 +77,7 @@ class AcsParameters : public HasParametersIF {
    float mgm02variance[3] = {pow(3.2e-7, 2), pow(3.2e-7, 2), pow(4.1e-7, 2)};
    float mgm13variance[3] = {pow(1.5e-8, 2), pow(1.5e-8, 2), pow(1.5e-8, 2)};
    float mgm4variance[3] = {pow(1.7e-6, 2), pow(1.7e-6, 2), pow(1.7e-6, 2)};
-    float mgmVectorFilterWeight = 0.85;
-    float mgmDerivativeFilterWeight = 0.85;
+    float mgmDerivativeFilterWeight = 0.5;
  } mgmHandlingParameters;

  struct SusHandlingParameters {
@ -768,8 +767,6 @@ class AcsParameters : public HasParametersIF {
         0.167666815691513, 0.163137400730063, -0.000609874123906977, -0.00205336098697513,
         -0.000889232196185857, -0.00168429567131815}};
    float susBrightnessThreshold = 0.7;
-    float susVectorFilterWeight = .85;
-    float susRateFilterWeight = .85;
  } susHandlingParameters;

  struct GyrHandlingParameters {
@ -828,22 +825,15 @@ class AcsParameters : public HasParametersIF {
    double k_alignMekf = 4.0e-5;
    double k_parallelMekf = 3.75e-4;

-    double k_orthoGyr = 4.4e-3;
-    double k_alignGyr = 4.0e-5;
-    double k_parallelGyr = 3.75e-4;
-
-    double k_orthoSusMgm = 1.1e-2;
-    double k_alignSusMgm = 2.0e-5;
-    double k_parallelSusMgm = 4.4e-4;
+    double k_orthoNonMekf = 4.4e-3;
+    double k_alignNonMekf = 4.0e-5;
+    double k_parallelNonMekf = 3.75e-4;

    double sunTargetDirLeop[3] = {0, sqrt(.5), sqrt(.5)};
    double sunTargetDir[3] = {0, 0, 1};

    uint8_t useMekf = false;
-    uint8_t useGyr = true;
    uint8_t dampingDuringEclipse = true;
-
-    float sineLimitSunRotRate = 0.24;
  } safeModeControllerParameters;

  struct PointingLawParameters {
--- a/mission/controller/acs/CMakeLists.txt
+++ b/mission/controller/acs/CMakeLists.txt
@ -2,7 +2,6 @@ target_sources(
  ${LIB_EIVE_MISSION}
  PRIVATE AcsParameters.cpp
          ActuatorCmd.cpp
-          FusedRotationEstimation.cpp
          Guidance.cpp
          Igrf13Model.cpp
          MultiplicativeKalmanFilter.cpp
--- a/mission/controller/acs/FusedRotationEstimation.cpp
+++ b/mission/controller/acs/FusedRotationEstimation.cpp
@ -1,103 +0,0 @@
-#include "FusedRotationEstimation.h"
-
-FusedRotationEstimation::FusedRotationEstimation(AcsParameters *acsParameters_) {
-  acsParameters = acsParameters_;
-}
-
-void FusedRotationEstimation::estimateFusedRotationRateSafe(
-    acsctrl::SusDataProcessed *susDataProcessed, acsctrl::MgmDataProcessed *mgmDataProcessed,
-    acsctrl::GyrDataProcessed *gyrDataProcessed, acsctrl::FusedRotRateData *fusedRotRateData) {
-  if ((not mgmDataProcessed->mgmVecTot.isValid() and not susDataProcessed->susVecTot.isValid() and
-       not fusedRotRateData->rotRateTotal.isValid()) or
-      (not susDataProcessed->susVecTotDerivative.isValid() and
-       not mgmDataProcessed->mgmVecTotDerivative.isValid())) {
-    {
-      PoolReadGuard pg(fusedRotRateData);
-      std::memcpy(fusedRotRateData->rotRateOrthogonal.value, ZERO_VEC, 3 * sizeof(double));
-      std::memcpy(fusedRotRateData->rotRateParallel.value, ZERO_VEC, 3 * sizeof(double));
-      std::memcpy(fusedRotRateData->rotRateTotal.value, ZERO_VEC, 3 * sizeof(double));
-      fusedRotRateData->setValidity(false, true);
-    }
-    return;
-  }
-  if (not susDataProcessed->susVecTot.isValid()) {
-    estimateFusedRotationRateEclipse(gyrDataProcessed, fusedRotRateData);
-    return;
-  }
-
-  // calculate rotation around the sun
-  double magSunCross[3] = {0, 0, 0};
-
-  VectorOperations<double>::cross(mgmDataProcessed->mgmVecTot.value,
-                                  susDataProcessed->susVecTot.value, magSunCross);
-  double magSunCrossNorm = VectorOperations<double>::norm(magSunCross, 3);
-  double magNorm = VectorOperations<double>::norm(mgmDataProcessed->mgmVecTot.value, 3);
-  double fusedRotRateParallel[3] = {0, 0, 0};
-  if (magSunCrossNorm >
-      (acsParameters->safeModeControllerParameters.sineLimitSunRotRate * magNorm)) {
-    double omegaParallel =
-        VectorOperations<double>::dot(mgmDataProcessed->mgmVecTotDerivative.value, magSunCross) *
-        pow(magSunCrossNorm, -2);
-    VectorOperations<double>::mulScalar(susDataProcessed->susVecTot.value, omegaParallel,
-                                        fusedRotRateParallel, 3);
-  } else {
-    estimateFusedRotationRateEclipse(gyrDataProcessed, fusedRotRateData);
-    return;
-  }
-
-  // calculate rotation orthogonal to the sun
-  double fusedRotRateOrthogonal[3] = {0, 0, 0};
-  VectorOperations<double>::cross(susDataProcessed->susVecTotDerivative.value,
-                                  susDataProcessed->susVecTot.value, fusedRotRateOrthogonal);
-  VectorOperations<double>::mulScalar(
-      fusedRotRateOrthogonal,
-      pow(VectorOperations<double>::norm(susDataProcessed->susVecTot.value, 3), -2),
-      fusedRotRateOrthogonal, 3);
-
-  // calculate total rotation rate
-  double fusedRotRateTotal[3] = {0, 0, 0};
-  VectorOperations<double>::add(fusedRotRateParallel, fusedRotRateOrthogonal, fusedRotRateTotal);
-
-  // store for calculation of angular acceleration
-  if (gyrDataProcessed->gyrVecTot.isValid()) {
-    std::memcpy(rotRateOldB, gyrDataProcessed->gyrVecTot.value, 3 * sizeof(double));
-  }
-
-  {
-    PoolReadGuard pg(fusedRotRateData);
-    std::memcpy(fusedRotRateData->rotRateOrthogonal.value, fusedRotRateOrthogonal,
-                3 * sizeof(double));
-    std::memcpy(fusedRotRateData->rotRateParallel.value, fusedRotRateParallel, 3 * sizeof(double));
-    std::memcpy(fusedRotRateData->rotRateTotal.value, fusedRotRateTotal, 3 * sizeof(double));
-    fusedRotRateData->setValidity(true, true);
-  }
-}
-
-void FusedRotationEstimation::estimateFusedRotationRateEclipse(
-    acsctrl::GyrDataProcessed *gyrDataProcessed, acsctrl::FusedRotRateData *fusedRotRateData) {
-  if (not gyrDataProcessed->gyrVecTot.isValid() or
-      VectorOperations<double>::norm(fusedRotRateData->rotRateTotal.value, 3) == 0) {
-    {
-      PoolReadGuard pg(fusedRotRateData);
-      std::memcpy(fusedRotRateData->rotRateOrthogonal.value, ZERO_VEC, 3 * sizeof(double));
-      std::memcpy(fusedRotRateData->rotRateParallel.value, ZERO_VEC, 3 * sizeof(double));
-      std::memcpy(fusedRotRateData->rotRateTotal.value, ZERO_VEC, 3 * sizeof(double));
-      fusedRotRateData->setValidity(false, true);
-    }
-    return;
-  }
-  double angAccelB[3] = {0, 0, 0};
-  VectorOperations<double>::subtract(gyrDataProcessed->gyrVecTot.value, rotRateOldB, angAccelB, 3);
-  double fusedRotRateTotal[3] = {0, 0, 0};
-  VectorOperations<double>::add(fusedRotRateData->rotRateTotal.value, angAccelB, fusedRotRateTotal,
-                                3);
-  {
-    PoolReadGuard pg(fusedRotRateData);
-    std::memcpy(fusedRotRateData->rotRateOrthogonal.value, ZERO_VEC, 3 * sizeof(double));
-    fusedRotRateData->rotRateOrthogonal.setValid(false);
-    std::memcpy(fusedRotRateData->rotRateParallel.value, ZERO_VEC, 3 * sizeof(double));
-    fusedRotRateData->rotRateParallel.setValid(false);
-    std::memcpy(fusedRotRateData->rotRateTotal.value, fusedRotRateTotal, 3 * sizeof(double));
-    fusedRotRateData->rotRateTotal.setValid(true);
-  }
-}
--- a/mission/controller/acs/FusedRotationEstimation.h
+++ b/mission/controller/acs/FusedRotationEstimation.h
@ -1,29 +0,0 @@
-#ifndef MISSION_CONTROLLER_ACS_FUSEDROTATIONESTIMATION_H_
-#define MISSION_CONTROLLER_ACS_FUSEDROTATIONESTIMATION_H_
-
-#include <fsfw/datapool/PoolReadGuard.h>
-#include <fsfw/globalfunctions/math/VectorOperations.h>
-#include <mission/controller/acs/AcsParameters.h>
-#include <mission/controller/controllerdefinitions/AcsCtrlDefinitions.h>
-
-class FusedRotationEstimation {
- public:
-  FusedRotationEstimation(AcsParameters *acsParameters_);
-
-  void estimateFusedRotationRateSafe(acsctrl::SusDataProcessed *susDataProcessed,
-                                     acsctrl::MgmDataProcessed *mgmDataProcessed,
-                                     acsctrl::GyrDataProcessed *gyrDataProcessed,
-                                     acsctrl::FusedRotRateData *fusedRotRateData);
-
- protected:
- private:
-  static constexpr double ZERO_VEC[3] = {0, 0, 0};
-
-  AcsParameters *acsParameters;
-  double rotRateOldB[3] = {0, 0, 0};
-
-  void estimateFusedRotationRateEclipse(acsctrl::GyrDataProcessed *gyrDataProcessed,
-                                        acsctrl::FusedRotRateData *fusedRotRateData);
-};
-
-#endif /* MISSION_CONTROLLER_ACS_FUSEDROTATIONESTIMATION_H_ */
--- a/mission/controller/acs/SensorProcessing.cpp
+++ b/mission/controller/acs/SensorProcessing.cpp
@ -132,10 +132,6 @@ void SensorProcessing::processMgm(const float *mgm0Value, bool mgm0valid, const
  for (uint8_t i = 0; i < 3; i++) {
    mgmVecTot[i] = sensorFusionNumerator[i] / sensorFusionDenominator[i];
  }
-  if (VectorOperations<double>::norm(mgmVecTot, 3) != 0 and mgmDataProcessed->mgmVecTot.isValid()) {
-    lowPassFilter(mgmVecTot, mgmDataProcessed->mgmVecTot.value,
-                  mgmParameters->mgmVectorFilterWeight);
-  }

  //-----------------------Mgm Rate Computation ---------------------------------------------------
  double mgmVecTotDerivative[3] = {0.0, 0.0, 0.0};
@ -355,11 +351,6 @@ void SensorProcessing::processSus(
  double susVecTot[3] = {0.0, 0.0, 0.0};
  VectorOperations<double>::normalize(susMeanValue, susVecTot, 3);

-  if (VectorOperations<double>::norm(susVecTot, 3) != 0 and susDataProcessed->susVecTot.isValid()) {
-    lowPassFilter(susVecTot, susDataProcessed->susVecTot.value,
-                  susParameters->susVectorFilterWeight);
-  }
-
  /* -------- Sun Derivatiative --------------------- */

  double susVecTotDerivative[3] = {0.0, 0.0, 0.0};
@ -372,11 +363,6 @@ void SensorProcessing::processSus(
      susVecTotDerivativeValid = true;
    }
  }
-  if (VectorOperations<double>::norm(susVecTotDerivative, 3) != 0 and
-      susDataProcessed->susVecTotDerivative.isValid()) {
-    lowPassFilter(susVecTotDerivative, susDataProcessed->susVecTotDerivative.value,
-                  susParameters->susRateFilterWeight);
-  }
  timeOfSavedSusDirEst = timeOfSusMeasurement;
  {
    PoolReadGuard pg(susDataProcessed);
--- a/mission/controller/acs/control/SafeCtrl.cpp
+++ b/mission/controller/acs/control/SafeCtrl.cpp
@ -9,36 +9,20 @@ SafeCtrl::SafeCtrl(AcsParameters *acsParameters_) { acsParameters = acsParameter

 SafeCtrl::~SafeCtrl() {}

-acs::SafeModeStrategy SafeCtrl::safeCtrlStrategy(
-    const bool magFieldValid, const bool mekfValid, const bool satRotRateValid,
-    const bool sunDirValid, const bool fusedRateSplitValid, const bool fusedRateTotalValid,
-    const uint8_t mekfEnabled, const uint8_t gyrEnabled, const uint8_t dampingEnabled) {
+acs::SafeModeStrategy SafeCtrl::safeCtrlStrategy(const bool magFieldValid, const bool mekfValid,
+                                                 const bool satRotRateValid, const bool sunDirValid,
+                                                 const uint8_t mekfEnabled,
+                                                 const uint8_t dampingEnabled) {
  if (not magFieldValid) {
    return acs::SafeModeStrategy::SAFECTRL_NO_MAG_FIELD_FOR_CONTROL;
  } else if (mekfEnabled and mekfValid) {
-    return acs::SafeModeStrategy::SAFECTRL_MEKF;
-  } else if (sunDirValid) {
-    if (gyrEnabled and satRotRateValid) {
-      return acs::SafeModeStrategy::SAFECTRL_GYR;
-    } else if (not gyrEnabled and fusedRateSplitValid) {
-      return acs::SafeModeStrategy::SAFECTRL_SUSMGM;
-    } else {
-      return acs::SafeModeStrategy::SAFECTRL_NO_SENSORS_FOR_CONTROL;
-    }
-  } else if (not sunDirValid) {
-    if (dampingEnabled) {
-      if (gyrEnabled and satRotRateValid) {
-        return acs::SafeModeStrategy::SAFECTRL_ECLIPSE_DAMPING_GYR;
-      } else if (not gyrEnabled and satRotRateValid and fusedRateTotalValid) {
-        return acs::SafeModeStrategy::SAFECTRL_ECLIPSE_DAMPING_SUSMGM;
-      } else {
-        return acs::SafeModeStrategy::SAFECTRL_NO_SENSORS_FOR_CONTROL;
-      }
-    } else if (not dampingEnabled and satRotRateValid) {
-      return acs::SafeModeStrategy::SAFECTRL_ECLIPSE_IDELING;
-    } else {
-      return acs::SafeModeStrategy::SAFECTRL_NO_SENSORS_FOR_CONTROL;
-    }
+    return acs::SafeModeStrategy::SAFECTRL_ACTIVE_MEKF;
+  } else if (satRotRateValid and sunDirValid) {
+    return acs::SafeModeStrategy::SAFECTRL_WITHOUT_MEKF;
+  } else if (dampingEnabled and satRotRateValid and not sunDirValid) {
+    return acs::SafeModeStrategy::SAFECTRL_ECLIPSE_DAMPING;
+  } else if (not dampingEnabled and satRotRateValid and not sunDirValid) {
+    return acs::SafeModeStrategy::SAFECTRL_ECLIPSE_IDELING;
  } else {
    return acs::SafeModeStrategy::SAFECTRL_NO_SENSORS_FOR_CONTROL;
  }
@ -59,7 +43,8 @@ void SafeCtrl::safeMekf(const double *magFieldB, const double *satRotRateB,
  errorAngle = acos(dotSun);

  splitRotationalRate(satRotRateB, sunDirB);
-  calculateRotationalRateTorque(acsParameters->safeModeControllerParameters.k_parallelMekf,
+  calculateRotationalRateTorque(sunDirB, sunDirRefB, errorAngle,
+                                acsParameters->safeModeControllerParameters.k_parallelMekf,
                                acsParameters->safeModeControllerParameters.k_orthoMekf);
  calculateAngleErrorTorque(sunDirB, sunDirRefB,
                            acsParameters->safeModeControllerParameters.k_alignMekf);
@ -72,8 +57,9 @@ void SafeCtrl::safeMekf(const double *magFieldB, const double *satRotRateB,
  calculateMagneticMoment(magMomB);
 }

-void SafeCtrl::safeGyr(const double *magFieldB, const double *satRotRateB, const double *sunDirB,
-                       const double *sunDirRefB, double *magMomB, double &errorAngle) {
+void SafeCtrl::safeNonMekf(const double *magFieldB, const double *satRotRateB,
+                           const double *sunDirB, const double *sunDirRefB, double *magMomB,
+                           double &errorAngle) {
  // convert magFieldB from uT to T
  VectorOperations<double>::mulScalar(magFieldB, 1e-6, magFieldBT, 3);

@ -82,10 +68,11 @@ void SafeCtrl::safeGyr(const double *magFieldB, const double *satRotRateB, const
  errorAngle = acos(dotSun);

  splitRotationalRate(satRotRateB, sunDirB);
-  calculateRotationalRateTorque(acsParameters->safeModeControllerParameters.k_parallelGyr,
-                                acsParameters->safeModeControllerParameters.k_orthoGyr);
+  calculateRotationalRateTorque(sunDirB, sunDirRefB, errorAngle,
+                                acsParameters->safeModeControllerParameters.k_parallelNonMekf,
+                                acsParameters->safeModeControllerParameters.k_orthoNonMekf);
  calculateAngleErrorTorque(sunDirB, sunDirRefB,
-                            acsParameters->safeModeControllerParameters.k_alignGyr);
+                            acsParameters->safeModeControllerParameters.k_alignNonMekf);

  // sum of all torques
  for (uint8_t i = 0; i < 3; i++) {
@ -95,33 +82,8 @@ void SafeCtrl::safeGyr(const double *magFieldB, const double *satRotRateB, const
  calculateMagneticMoment(magMomB);
 }

-void SafeCtrl::safeSusMgm(const double *magFieldB, const double *rotRateParallelB,
-                          const double *rotRateOrthogonalB, const double *sunDirB,
-                          const double *sunDirRefB, double *magMomB, double &errorAngle) {
-  // convert magFieldB from uT to T
-  VectorOperations<double>::mulScalar(magFieldB, 1e-6, magFieldBT, 3);
-
-  // calculate error angle between sunDirRef and sunDir
-  double dotSun = VectorOperations<double>::dot(sunDirRefB, sunDirB);
-  errorAngle = acos(dotSun);
-
-  std::memcpy(satRotRateParallelB, rotRateParallelB, sizeof(satRotRateParallelB));
-  std::memcpy(satRotRateOrthogonalB, rotRateOrthogonalB, sizeof(satRotRateOrthogonalB));
-  calculateRotationalRateTorque(acsParameters->safeModeControllerParameters.k_parallelSusMgm,
-                                acsParameters->safeModeControllerParameters.k_orthoSusMgm);
-  calculateAngleErrorTorque(sunDirB, sunDirRefB,
-                            acsParameters->safeModeControllerParameters.k_alignSusMgm);
-
-  // sum of all torques
-  for (uint8_t i = 0; i < 3; i++) {
-    cmdTorque[i] = cmdAlign[i] + cmdOrtho[i] + cmdParallel[i];
-  }
-
-  calculateMagneticMoment(magMomB);
-}
-
-void SafeCtrl::safeRateDampingGyr(const double *magFieldB, const double *satRotRateB,
-                                  const double *sunDirRefB, double *magMomB, double &errorAngle) {
+void SafeCtrl::safeRateDamping(const double *magFieldB, const double *satRotRateB,
+                               const double *sunDirRefB, double *magMomB, double &errorAngle) {
  // convert magFieldB from uT to T
  VectorOperations<double>::mulScalar(magFieldB, 1e-6, magFieldBT, 3);

@ -129,28 +91,9 @@ void SafeCtrl::safeRateDampingGyr(const double *magFieldB, const double *satRotR
  errorAngle = NAN;

  splitRotationalRate(satRotRateB, sunDirRefB);
-  calculateRotationalRateTorque(acsParameters->safeModeControllerParameters.k_parallelGyr,
-                                acsParameters->safeModeControllerParameters.k_orthoGyr);
-
-  // sum of all torques
-  VectorOperations<double>::add(cmdParallel, cmdOrtho, cmdTorque, 3);
-
-  // calculate magnetic moment to command
-  calculateMagneticMoment(magMomB);
-}
-
-void SafeCtrl::safeRateDampingSusMgm(const double *magFieldB, const double *satRotRateB,
-                                     const double *sunDirRefB, double *magMomB,
-                                     double &errorAngle) {
-  // convert magFieldB from uT to T
-  VectorOperations<double>::mulScalar(magFieldB, 1e-6, magFieldBT, 3);
-
-  // no error angle available for eclipse
-  errorAngle = NAN;
-
-  splitRotationalRate(satRotRateB, sunDirRefB);
-  calculateRotationalRateTorque(acsParameters->safeModeControllerParameters.k_parallelSusMgm,
-                                acsParameters->safeModeControllerParameters.k_orthoSusMgm);
+  calculateRotationalRateTorque(sunDirRefB, sunDirRefB, errorAngle,
+                                acsParameters->safeModeControllerParameters.k_parallelNonMekf,
+                                acsParameters->safeModeControllerParameters.k_orthoNonMekf);

  // sum of all torques
  VectorOperations<double>::add(cmdParallel, cmdOrtho, cmdTorque, 3);
@ -167,7 +110,9 @@ void SafeCtrl::splitRotationalRate(const double *satRotRateB, const double *sunD
  VectorOperations<double>::subtract(satRotRateB, satRotRateParallelB, satRotRateOrthogonalB, 3);
 }

-void SafeCtrl::calculateRotationalRateTorque(const double gainParallel, const double gainOrtho) {
+void SafeCtrl::calculateRotationalRateTorque(const double *sunDirB, const double *sunDirRefB,
+                                             double &errorAngle, const double gainParallel,
+                                             const double gainOrtho) {
  // calculate torque for parallel rotational rate
  VectorOperations<double>::mulScalar(satRotRateParallelB, -gainParallel, cmdParallel, 3);

--- a/mission/controller/acs/control/SafeCtrl.h
+++ b/mission/controller/acs/control/SafeCtrl.h
@ -14,34 +14,23 @@ class SafeCtrl {

  acs::SafeModeStrategy safeCtrlStrategy(const bool magFieldValid, const bool mekfValid,
                                         const bool satRotRateValid, const bool sunDirValid,
-                                         const bool fusedRateSplitValid,
-                                         const bool fusedRateTotalValid, const uint8_t mekfEnabled,
-                                         const uint8_t gyrEnabled, const uint8_t dampingEnabled);
+                                         const uint8_t mekfEnabled, const uint8_t dampingEnabled);

  void safeMekf(const double *magFieldB, const double *satRotRateB, const double *sunDirModelI,
                const double *quatBI, const double *sunDirRefB, double *magMomB,
                double &errorAngle);

-  void safeGyr(const double *magFieldB, const double *satRotRateB, const double *sunDirB,
-               const double *sunDirRefB, double *magMomB, double &errorAngle);
+  void safeNonMekf(const double *magFieldB, const double *satRotRateB, const double *sunDirB,
+                   const double *sunDirRefB, double *magMomB, double &errorAngle);

-  void safeSusMgm(const double *magFieldB, const double *rotRateParallelB,
-                  const double *rotRateOrthogonalB, const double *sunDirB, const double *sunDirRefB,
-                  double *magMomB, double &errorAngle);
-
-  void safeRateDampingGyr(const double *magFieldB, const double *satRotRateB,
-                          const double *sunDirRefB, double *magMomB, double &errorAngle);
-
-  void safeRateDampingSusMgm(const double *magFieldB, const double *satRotRateB,
-                             const double *sunDirRefB, double *magMomB, double &errorAngle);
+  void safeRateDamping(const double *magFieldB, const double *satRotRateB, const double *sunDirRefB,
+                       double *magMomB, double &errorAngle);

  void splitRotationalRate(const double *satRotRateB, const double *sunDirB);

-  void calculateRotationalRates(const double *magFieldB, const double *magRateB,
-                                const double *sunDirB, const double *sunRateB,
-                                double *fusedRotRate);
-
-  void calculateRotationalRateTorque(const double gainParallel, const double gainOrtho);
+  void calculateRotationalRateTorque(const double *sunDirB, const double *sunDirRefB,
+                                     double &errorAngle, const double gainParallel,
+                                     const double gainOrtho);

  void calculateAngleErrorTorque(const double *sunDirB, const double *sunDirRefB,
                                 const double gainAlign);
--- a/mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
+++ b/mission/controller/controllerdefinitions/AcsCtrlDefinitions.h
@ -18,8 +18,7 @@ enum SetIds : uint32_t {
  GPS_PROCESSED_DATA,
  MEKF_DATA,
  CTRL_VAL_DATA,
-  ACTUATOR_CMD_DATA,
-  FUSED_ROTATION_RATE_DATA,
+  ACTUATOR_CMD_DATA
 };

 enum PoolIds : lp_id_t {
@ -104,10 +103,6 @@ enum PoolIds : lp_id_t {
  RW_TARGET_TORQUE,
  RW_TARGET_SPEED,
  MTQ_TARGET_DIPOLE,
-  // Fused Rotation Rate
-  ROT_RATE_ORTHOGONAL,
-  ROT_RATE_PARALLEL,
-  ROT_RATE_TOTAL,
 };

 static constexpr uint8_t MGM_SET_RAW_ENTRIES = 6;
@ -120,7 +115,6 @@ static constexpr uint8_t GPS_SET_PROCESSED_ENTRIES = 5;
 static constexpr uint8_t MEKF_SET_ENTRIES = 3;
 static constexpr uint8_t CTRL_VAL_SET_ENTRIES = 5;
 static constexpr uint8_t ACT_CMD_SET_ENTRIES = 3;
-static constexpr uint8_t FUSED_ROT_RATE_SET_ENTRIES = 3;

 /**
 * @brief   Raw MGM sensor data. Includes the IMTQ sensor data and actuator status.
@ -279,19 +273,6 @@ class ActuatorCmdData : public StaticLocalDataSet<ACT_CMD_SET_ENTRIES> {
 private:
 };

-class FusedRotRateData : public StaticLocalDataSet<FUSED_ROT_RATE_SET_ENTRIES> {
- public:
-  FusedRotRateData(HasLocalDataPoolIF* hkOwner)
-      : StaticLocalDataSet(hkOwner, FUSED_ROTATION_RATE_DATA) {}
-
-  lp_vec_t<double, 3> rotRateOrthogonal =
-      lp_vec_t<double, 3>(sid.objectId, ROT_RATE_ORTHOGONAL, this);
-  lp_vec_t<double, 3> rotRateParallel = lp_vec_t<double, 3>(sid.objectId, ROT_RATE_PARALLEL, this);
-  lp_vec_t<double, 3> rotRateTotal = lp_vec_t<double, 3>(sid.objectId, ROT_RATE_TOTAL, this);
-
- private:
-};
-
 }  // namespace acsctrl

 #endif /* MISSION_CONTROLLER_CONTROLLERDEFINITIONS_ACSCTRLDEFINITIONS_H_ */
--- a/mission/controller/tcsDefs.h
+++ b/mission/controller/tcsDefs.h
@ -9,85 +9,6 @@

 namespace tcsCtrl {

-/**
- * NOP Limit: Hard limit for device, usually from datasheet. Device damage is possible lif NOP limit
- * is exceeded.
- * OP Limit: Soft limit. Device should be switched off or TCS controller should take action if the
- * limit is exceeded to avoid reaching NOP limit
- */
-struct TempLimits {
-  TempLimits(float nopLowerLimit, float opLowerLimit, float cutOffLimit, float opUpperLimit,
-             float nopUpperLimit)
-      : opLowerLimit(opLowerLimit),
-        opUpperLimit(opUpperLimit),
-        cutOffLimit(cutOffLimit),
-        nopLowerLimit(nopLowerLimit),
-        nopUpperLimit(nopUpperLimit) {}
-  float opLowerLimit;
-  float opUpperLimit;
-  float cutOffLimit;
-  float nopLowerLimit;
-  float nopUpperLimit;
-};
-
-/**
- * Abstraction for the state of a single thermal component
- */
-struct ThermalState {
-  uint8_t noSensorAvailableCounter;
-  // Which sensor is used for this component?
-  uint8_t sensorIndex = 0;
-  // Is heating on for that thermal module?
-  bool heating = false;
-  // Which switch is being used for heating the component
-  heater::Switch heaterSwitch = heater::Switch::HEATER_NONE;
-  // Heater start time and end times as UNIX seconds. Please note that these times will be updated
-  // when a switch command is sent, with no guarantess that the heater actually went on.
-  uint32_t heaterStartTime = 0;
-  uint32_t heaterEndTime = 0;
-};
-
-/**
- * Abstraction for the state of a single heater.
- */
-struct HeaterState {
-  bool switchTransition = false;
-  heater::SwitchState target = heater::SwitchState::OFF;
-  uint8_t heaterSwitchControlCycles = 0;
-  bool trackHeaterMaxBurnTime = false;
-  Countdown heaterOnMaxBurnTime;
-};
-
-using HeaterSwitchStates = std::array<heater::SwitchState, heater::NUMBER_OF_SWITCHES>;
-
-enum ThermalComponents : uint8_t {
-  NONE = 0,
-  ACS_BOARD = 1,
-  MGT = 2,
-  RW = 3,
-  STR = 4,
-  IF_BOARD = 5,
-  TCS_BOARD = 6,
-  OBC = 7,
-  LEGACY_OBCIF_BOARD = 8,
-  SBAND_TRANSCEIVER = 9,
-  PCDUP60_BOARD = 10,
-  PCDUACU = 11,
-  PCDUPDU = 12,
-  PLPCDU_BOARD = 13,
-  PLOCMISSION_BOARD = 14,
-  PLOCPROCESSING_BOARD = 15,
-  DAC = 16,
-  CAMERA = 17,
-  DRO = 18,
-  X8 = 19,
-  HPA = 20,
-  TX = 21,
-  MPA = 22,
-  SCEX_BOARD = 23,
-  NUM_THERMAL_COMPONENTS
-};
-
 static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::TCS_CONTROLLER;
 static constexpr Event NO_VALID_SENSOR_TEMPERATURE = MAKE_EVENT(0, severity::MEDIUM);
 static constexpr Event NO_HEALTHY_HEATER_AVAILABLE = MAKE_EVENT(1, severity::MEDIUM);
@ -97,12 +18,6 @@ static constexpr Event CAMERA_OVERHEATING = MAKE_EVENT(5, severity::HIGH);
 static constexpr Event PCDU_SYSTEM_OVERHEATING = MAKE_EVENT(6, severity::HIGH);
 static constexpr Event HEATER_NOT_OFF_FOR_OFF_MODE = MAKE_EVENT(7, severity::MEDIUM);
 static constexpr Event MGT_OVERHEATING = MAKE_EVENT(8, severity::HIGH);
-//! [EXPORT] : [COMMENT] P1: Module index. P2: Heater index
-static constexpr Event TCS_SWITCHING_HEATER_ON = MAKE_EVENT(9, severity::INFO);
-//! [EXPORT] : [COMMENT] P1: Module index. P2: Heater index
-static constexpr Event TCS_SWITCHING_HEATER_OFF = MAKE_EVENT(10, severity::INFO);
-//! [EXPORT] : [COMMENT] P1: Heater index. P2: Maximum burn time for heater.
-static constexpr Event TCS_HEATER_MAX_BURN_TIME_REACHED = MAKE_EVENT(11, severity::MEDIUM);

 enum SetId : uint32_t {
  SENSOR_TEMPERATURES = 0,
@ -110,7 +25,6 @@ enum SetId : uint32_t {
  SUS_TEMPERATURES = 2,
  COMPONENT_TEMPERATURES = 3,
  HEATER_SET = 4,
-  TCS_CTRL_INFO = 5
 };

 enum PoolIds : lp_id_t {
@ -178,13 +92,7 @@ enum PoolIds : lp_id_t {
  TEMP_ADC_PAYLOAD_PCDU,

  HEATER_SWITCH_LIST,
-  HEATER_CURRENT,
-
-  HEATER_ON_FOR_COMPONENT_VEC,
-  SENSOR_USED_FOR_TCS_CTRL,
-  HEATER_IDX_USED_FOR_TCS_CTRL,
-  HEATER_START_TIME,
-  HEATER_END_TIME
+  HEATER_CURRENT
 };

 static const uint8_t ENTRIES_SENSOR_TEMPERATURE_SET = 25;
@ -324,29 +232,6 @@ class HeaterInfo : public StaticLocalDataSet<3> {
  lp_var_t<int16_t> heaterCurrent = lp_var_t<int16_t>(sid.objectId, PoolIds::HEATER_CURRENT, this);
 };

-class TcsCtrlInfo : public StaticLocalDataSet<6> {
- public:
-  explicit TcsCtrlInfo(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TCS_CTRL_INFO) {}
-
-  explicit TcsCtrlInfo(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, TCS_CTRL_INFO)) {}
-
-  lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS> heatingOnVec =
-      lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(
-          sid.objectId, PoolIds::HEATER_ON_FOR_COMPONENT_VEC, this);
-  lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS> sensorIdxUsedForTcsCtrl =
-      lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(sid.objectId,
-                                                         PoolIds::SENSOR_USED_FOR_TCS_CTRL, this);
-  lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS> heaterSwitchIdx =
-      lp_vec_t<uint8_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(
-          sid.objectId, PoolIds::HEATER_IDX_USED_FOR_TCS_CTRL, this);
-  lp_vec_t<uint32_t, tcsCtrl::NUM_THERMAL_COMPONENTS> heaterStartTimes =
-      lp_vec_t<uint32_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(sid.objectId, PoolIds::HEATER_START_TIME,
-                                                          this);
-  lp_vec_t<uint32_t, tcsCtrl::NUM_THERMAL_COMPONENTS> heaterEndTimes =
-      lp_vec_t<uint32_t, tcsCtrl::NUM_THERMAL_COMPONENTS>(sid.objectId, PoolIds::HEATER_END_TIME,
-                                                          this);
-};
-
 }  // namespace tcsCtrl

 #endif /* MISSION_CONTROLLER_CONTROLLERDEFINITIONS_THERMALCONTROLLERDEFINITIONS_H_ */
--- a/mission/genericFactory.cpp
+++ b/mission/genericFactory.cpp
@ -91,21 +91,19 @@ EiveFaultHandler EIVE_FAULT_HANDLER;
 }  // namespace cfdp

 std::atomic_bool tcs::TCS_BOARD_SHORTLY_UNAVAILABLE = false;
-std::atomic_bool core::SAVE_PUS_SEQUENCE_COUNT = false;
-std::atomic_bool core::SAVE_CFDP_SEQUENCE_COUNT = false;

 void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFunnel** pusFunnel,
                                          CfdpTmFunnel** cfdpFunnel, SdCardMountedIF& sdcMan,
                                          StorageManagerIF** ipcStore, StorageManagerIF** tmStore,
                                          PersistentTmStores& stores,
-                                          uint32_t eventManagerQueueDepth, bool enableHkSets) {
+                                          uint32_t eventManagerQueueDepth) {
  // Framework objects
  new EventManager(objects::EVENT_MANAGER, eventManagerQueueDepth);
  auto healthTable = new HealthTable(objects::HEALTH_TABLE);
  if (healthTable_ != nullptr) {
    *healthTable_ = healthTable;
  }
-  new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER, 5, enableHkSets, 120);
+  new InternalErrorReporter(objects::INTERNAL_ERROR_REPORTER);
  new VerificationReporter();
  auto* timeStamper = new CdsShortTimeStamper(objects::TIME_STAMPER);
  StorageManagerIF* tcStore;
@ -157,11 +155,9 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
  new PusDistributor(config::EIVE_PUS_APID, objects::PUS_PACKET_DISTRIBUTOR, ccsdsDistrib);

  PusTmFunnel::FunnelCfg pusFunnelCfg(objects::PUS_TM_FUNNEL, "PusTmFunnel", **tmStore, **ipcStore,
-                                      config::MAX_PUS_FUNNEL_QUEUE_DEPTH, sdcMan,
-                                      config::PUS_SEQUENCE_COUNT_FILE,
-                                      core::SAVE_PUS_SEQUENCE_COUNT);
+                                      config::MAX_PUS_FUNNEL_QUEUE_DEPTH);
  // The PUS funnel routes all live TM to the live destinations and to the TM stores.
-  *pusFunnel = new PusTmFunnel(pusFunnelCfg, *ramToFileStore, *timeStamper);
+  *pusFunnel = new PusTmFunnel(pusFunnelCfg, *ramToFileStore, *timeStamper, sdcMan);

  // MISC store and PUS funnel to MISC store routing
  {
@ -220,9 +216,7 @@ void ObjectFactory::produceGenericObjects(HealthTableIF** healthTable_, PusTmFun
                                      stores.cfdpStore->getReportReceptionQueue(0));
  }
  PusTmFunnel::FunnelCfg cfdpFunnelCfg(objects::CFDP_TM_FUNNEL, "CfdpTmFunnel", **tmStore,
-                                       **ipcStore, config::MAX_CFDP_FUNNEL_QUEUE_DEPTH, sdcMan,
-                                       config::CFDP_SEQUENCE_COUNT_FILE,
-                                       core::SAVE_CFDP_SEQUENCE_COUNT);
+                                       **ipcStore, config::MAX_CFDP_FUNNEL_QUEUE_DEPTH);
  *cfdpFunnel = new CfdpTmFunnel(cfdpFunnelCfg, stores.cfdpStore->getReportReceptionQueue(0),
                                 *ramToFileStore, config::EIVE_CFDP_APID);

@ -311,9 +305,9 @@ void ObjectFactory::createGenericHeaterComponents(GpioIF& gpioIF, PowerSwitchIF&
  heaterHandler->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
 }

-void ObjectFactory::createThermalController(HeaterHandler& heaterHandler, bool pollPlPcduTmp1) {
+void ObjectFactory::createThermalController(HeaterHandler& heaterHandler) {
  auto* tcsCtrl = new ThermalController(objects::THERMAL_CONTROLLER, heaterHandler,
-                                        tcs::TCS_BOARD_SHORTLY_UNAVAILABLE, pollPlPcduTmp1);
+                                        tcs::TCS_BOARD_SHORTLY_UNAVAILABLE);
  tcsCtrl->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
 }
 void ObjectFactory::createRwAssy(PowerSwitchIF& pwrSwitcher, power::Switch_t theSwitch,
--- a/mission/genericFactory.h
+++ b/mission/genericFactory.h
@ -45,12 +45,11 @@ namespace ObjectFactory {
 void produceGenericObjects(HealthTableIF** healthTable, PusTmFunnel** pusFunnel,
                           CfdpTmFunnel** cfdpFunnel, SdCardMountedIF& sdcMan,
                           StorageManagerIF** ipcStore, StorageManagerIF** tmStore,
-                           PersistentTmStores& stores, uint32_t eventManagerQueueDepth,
-                           bool enableHkSets);
+                           PersistentTmStores& stores, uint32_t eventManagerQueueDepth);
 void createGenericHeaterComponents(GpioIF& gpioIF, PowerSwitchIF& pwrSwitcher,
                                   HeaterHandler*& heaterHandler);

-void createThermalController(HeaterHandler& heaterHandler, bool pollPlPcduTmp1);
+void createThermalController(HeaterHandler& heaterHandler);
 void createRwAssy(PowerSwitchIF& pwrSwitcher, power::Switch_t theSwitch,
                  std::array<DeviceHandlerBase*, 4> rws, std::array<object_id_t, 4> rwIds);
 void createSusAssy(PowerSwitchIF& pwrSwitcher, std::array<DeviceHandlerBase*, 12> suses);
--- a/mission/payload/RadiationSensorHandler.cpp
+++ b/mission/payload/RadiationSensorHandler.cpp
@ -1,7 +1,6 @@
 #include <OBSWConfig.h>
 #include <devices/gpioIds.h>
 #include <fsfw/datapool/PoolReadGuard.h>
-#include <fsfw/tasks/TaskFactory.h>
 #include <mission/payload/RadiationSensorHandler.h>
 #include <mission/power/gsDefs.h>
 #include <mission/tcs/max1227.h>
@ -16,8 +15,6 @@ RadiationSensorHandler::RadiationSensorHandler(object_id_t objectId, object_id_t
  if (comCookie == nullptr) {
    sif::error << "RadiationSensorHandler: Invalid com cookie" << std::endl;
  }
-  // Time out immediately so we get an immediate measurement at device startup.
-  measurementCd.timeOut();
 }

 RadiationSensorHandler::~RadiationSensorHandler() {}
@ -54,17 +51,14 @@ void RadiationSensorHandler::doShutDown() {
 }

 ReturnValue_t RadiationSensorHandler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
-  if (measurementCd.isBusy()) {
-    return NOTHING_TO_SEND;
-  }
  switch (communicationStep) {
    case CommunicationStep::START_CONVERSION: {
-      *id = radSens::START_CONVERSION;
+      *id = RAD_SENSOR::START_CONVERSION;
      communicationStep = CommunicationStep::READ_CONVERSIONS;
      break;
    }
    case CommunicationStep::READ_CONVERSIONS: {
-      *id = radSens::READ_CONVERSIONS;
+      *id = RAD_SENSOR::READ_CONVERSIONS;
      communicationStep = CommunicationStep::START_CONVERSION;
      break;
    }
@ -79,7 +73,7 @@ ReturnValue_t RadiationSensorHandler::buildNormalDeviceCommand(DeviceCommandId_t

 ReturnValue_t RadiationSensorHandler::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
  if (internalState == InternalState::SETUP) {
-    *id = radSens::WRITE_SETUP;
+    *id = RAD_SENSOR::WRITE_SETUP;
  } else {
    return NOTHING_TO_SEND;
  }
@ -90,19 +84,15 @@ ReturnValue_t RadiationSensorHandler::buildCommandFromCommand(DeviceCommandId_t
                                                              const uint8_t *commandData,
                                                              size_t commandDataLen) {
  switch (deviceCommand) {
-    case (radSens::WRITE_SETUP): {
-      cmdBuffer[0] = radSens::SETUP_DEFINITION;
+    case (RAD_SENSOR::WRITE_SETUP): {
+      cmdBuffer[0] = RAD_SENSOR::SETUP_DEFINITION;
      rawPacket = cmdBuffer;
      rawPacketLen = 1;
      internalState = InternalState::CONFIGURED;
      return returnvalue::OK;
    }
-    case (radSens::START_CONVERSION): {
+    case (RAD_SENSOR::START_CONVERSION): {
      ReturnValue_t result = gpioIF->pullHigh(gpioIds::ENABLE_RADFET);
-      // Test a small delay between pulling the RADFET high and reading the sensor. As long as this
-      // delay remains small enough, this should not cause scheduling issues. Do not make this
-      // delay large, this device might be scheduled inside the ACS PST!
-      TaskFactory::delayTask(5);
      if (result != returnvalue::OK) {
 #if OBSW_VERBOSE_LEVEL >= 1
        sif::warning
@ -112,25 +102,25 @@ ReturnValue_t RadiationSensorHandler::buildCommandFromCommand(DeviceCommandId_t
 #endif
      }
      /* First the fifo will be reset here */
-      cmdBuffer[0] = radSens::RESET_DEFINITION;
-      cmdBuffer[1] = radSens::CONVERSION_DEFINITION;
+      cmdBuffer[0] = RAD_SENSOR::RESET_DEFINITION;
+      cmdBuffer[1] = RAD_SENSOR::CONVERSION_DEFINITION;
      rawPacket = cmdBuffer;
      rawPacketLen = 2;
      return returnvalue::OK;
    }
-    case (radSens::READ_CONVERSIONS): {
-      cmdBuffer[0] = radSens::DUMMY_BYTE;
-      std::memset(cmdBuffer, radSens::DUMMY_BYTE, radSens::READ_SIZE);
+    case (RAD_SENSOR::READ_CONVERSIONS): {
+      cmdBuffer[0] = RAD_SENSOR::DUMMY_BYTE;
+      std::memset(cmdBuffer, RAD_SENSOR::DUMMY_BYTE, RAD_SENSOR::READ_SIZE);
      rawPacket = cmdBuffer;
-      rawPacketLen = radSens::READ_SIZE;
+      rawPacketLen = RAD_SENSOR::READ_SIZE;
      return returnvalue::OK;
    }
-    case radSens::ENABLE_DEBUG_OUTPUT: {
+    case RAD_SENSOR::ENABLE_DEBUG_OUTPUT: {
      printPeriodicData = true;
      rawPacketLen = 0;
      return returnvalue::OK;
    }
-    case radSens::DISABLE_DEBUG_OUTPUT: {
+    case RAD_SENSOR::DISABLE_DEBUG_OUTPUT: {
      rawPacketLen = 0;
      printPeriodicData = false;
      return returnvalue::OK;
@ -142,11 +132,12 @@ ReturnValue_t RadiationSensorHandler::buildCommandFromCommand(DeviceCommandId_t
 }

 void RadiationSensorHandler::fillCommandAndReplyMap() {
-  this->insertInCommandMap(radSens::WRITE_SETUP);
-  this->insertInCommandMap(radSens::START_CONVERSION);
-  this->insertInCommandMap(radSens::ENABLE_DEBUG_OUTPUT);
-  this->insertInCommandMap(radSens::DISABLE_DEBUG_OUTPUT);
-  this->insertInCommandAndReplyMap(radSens::READ_CONVERSIONS, 1, &dataset, radSens::READ_SIZE);
+  this->insertInCommandMap(RAD_SENSOR::WRITE_SETUP);
+  this->insertInCommandMap(RAD_SENSOR::START_CONVERSION);
+  this->insertInCommandMap(RAD_SENSOR::ENABLE_DEBUG_OUTPUT);
+  this->insertInCommandMap(RAD_SENSOR::DISABLE_DEBUG_OUTPUT);
+  this->insertInCommandAndReplyMap(RAD_SENSOR::READ_CONVERSIONS, 1, &dataset,
+                                   RAD_SENSOR::READ_SIZE);
 }

 ReturnValue_t RadiationSensorHandler::scanForReply(const uint8_t *start, size_t remainingSize,
@ -154,11 +145,11 @@ ReturnValue_t RadiationSensorHandler::scanForReply(const uint8_t *start, size_t
  *foundId = this->getPendingCommand();

  switch (*foundId) {
-    case radSens::START_CONVERSION:
-    case radSens::WRITE_SETUP:
+    case RAD_SENSOR::START_CONVERSION:
+    case RAD_SENSOR::WRITE_SETUP:
      *foundLen = remainingSize;
      return IGNORE_REPLY_DATA;
-    case radSens::READ_CONVERSIONS: {
+    case RAD_SENSOR::READ_CONVERSIONS: {
      ReturnValue_t result = gpioIF->pullLow(gpioIds::ENABLE_RADFET);
      if (result != returnvalue::OK) {
 #if OBSW_VERBOSE_LEVEL >= 1
@ -169,8 +160,8 @@ ReturnValue_t RadiationSensorHandler::scanForReply(const uint8_t *start, size_t
      }
      break;
    }
-    case radSens::ENABLE_DEBUG_OUTPUT:
-    case radSens::DISABLE_DEBUG_OUTPUT:
+    case RAD_SENSOR::ENABLE_DEBUG_OUTPUT:
+    case RAD_SENSOR::DISABLE_DEBUG_OUTPUT:
      sif::info << "RadiationSensorHandler::scanForReply: " << remainingSize << std::endl;
      break;
    default:
@ -185,27 +176,24 @@ ReturnValue_t RadiationSensorHandler::scanForReply(const uint8_t *start, size_t
 ReturnValue_t RadiationSensorHandler::interpretDeviceReply(DeviceCommandId_t id,
                                                           const uint8_t *packet) {
  switch (id) {
-    case radSens::READ_CONVERSIONS: {
+    case RAD_SENSOR::READ_CONVERSIONS: {
      uint8_t offset = 0;
-      measurementCd.resetTimer();
-      {
-        PoolReadGuard readSet(&dataset);
-        uint16_t tempRaw = ((packet[offset] & 0x0f) << 8) | packet[offset + 1];
-        dataset.temperatureCelcius = max1227::getTemperature(tempRaw);
-        offset += 2;
-        dataset.ain0 = (*(packet + offset) << 8) | *(packet + offset + 1);
-        offset += 2;
-        dataset.ain1 = (*(packet + offset) << 8) | *(packet + offset + 1);
-        offset += 6;
-        dataset.ain4 = (*(packet + offset) << 8) | *(packet + offset + 1);
-        offset += 2;
-        dataset.ain5 = (*(packet + offset) << 8) | *(packet + offset + 1);
-        offset += 2;
-        dataset.ain6 = (*(packet + offset) << 8) | *(packet + offset + 1);
-        offset += 2;
-        dataset.ain7 = (*(packet + offset) << 8) | *(packet + offset + 1);
-        dataset.setValidity(true, true);
-      }
+      PoolReadGuard readSet(&dataset);
+      uint16_t tempRaw = ((packet[offset] & 0x0f) << 8) | packet[offset + 1];
+      dataset.temperatureCelcius = max1227::getTemperature(tempRaw);
+      offset += 2;
+      dataset.ain0 = (*(packet + offset) << 8) | *(packet + offset + 1);
+      offset += 2;
+      dataset.ain1 = (*(packet + offset) << 8) | *(packet + offset + 1);
+      offset += 6;
+      dataset.ain4 = (*(packet + offset) << 8) | *(packet + offset + 1);
+      offset += 2;
+      dataset.ain5 = (*(packet + offset) << 8) | *(packet + offset + 1);
+      offset += 2;
+      dataset.ain6 = (*(packet + offset) << 8) | *(packet + offset + 1);
+      offset += 2;
+      dataset.ain7 = (*(packet + offset) << 8) | *(packet + offset + 1);
+      dataset.setValidity(true, true);
      if (printPeriodicData) {
        sif::info << "Radiation sensor temperature: " << dataset.temperatureCelcius << " °C"
                  << std::dec << std::endl;
@ -216,12 +204,6 @@ ReturnValue_t RadiationSensorHandler::interpretDeviceReply(DeviceCommandId_t id,
        sif::info << "Radiation sensor ADC value channel 6: " << dataset.ain6 << std::endl;
        sif::info << "Radiation sensor ADC value channel 7: " << dataset.ain7 << std::endl;
      }
-      ReturnValue_t result =
-          getHkManagerHandle()->generateHousekeepingPacket(dataset.getSid(), &dataset, true);
-      if (result != returnvalue::OK) {
-        // TODO: Maybe add event?
-        sif::error << "Generating HK set for radiation sensor failed" << std::endl;
-      }
      break;
    }
    default: {
@ -238,18 +220,15 @@ uint32_t RadiationSensorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t mo

 ReturnValue_t RadiationSensorHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                              LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(radSens::TEMPERATURE_C, new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(radSens::AIN0, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(radSens::AIN1, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(radSens::AIN4, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(radSens::AIN5, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(radSens::AIN6, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(radSens::AIN7, new PoolEntry<uint16_t>({0}));
-  // It should normally not be necessary to enable this set, as a sample TM will be generated
-  // after a measurement. If this is still enabled, sample with double the measurement frequency
-  // to ensure we get all measurements.
+  localDataPoolMap.emplace(RAD_SENSOR::TEMPERATURE_C, new PoolEntry<float>({0.0}));
+  localDataPoolMap.emplace(RAD_SENSOR::AIN0, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(RAD_SENSOR::AIN1, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(RAD_SENSOR::AIN4, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(RAD_SENSOR::AIN5, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(RAD_SENSOR::AIN6, new PoolEntry<uint16_t>({0}));
+  localDataPoolMap.emplace(RAD_SENSOR::AIN7, new PoolEntry<uint16_t>({0}));
  poolManager.subscribeForRegularPeriodicPacket(
-      subdp::RegularHkPeriodicParams(dataset.getSid(), false, DEFAULT_MEASUREMENT_CD_MS / 2));
+      subdp::RegularHkPeriodicParams(dataset.getSid(), false, 20.0));
  return returnvalue::OK;
 }

--- a/mission/payload/RadiationSensorHandler.h
+++ b/mission/payload/RadiationSensorHandler.h
@ -38,16 +38,13 @@ class RadiationSensorHandler : public DeviceHandlerBase {
                                        LocalDataPoolManager &poolManager) override;

 private:
-  static constexpr uint32_t DEFAULT_MEASUREMENT_CD_MS = 30 * 60 * 1000;
-
  enum class CommunicationStep { START_CONVERSION, READ_CONVERSIONS };

  enum class InternalState { OFF, POWER_SWITCHING, SETUP, CONFIGURED };

  bool printPeriodicData = false;
-  radSens::RadSensorDataset dataset;
-  Countdown measurementCd = Countdown(DEFAULT_MEASUREMENT_CD_MS);
-  static const uint8_t MAX_CMD_LEN = radSens::READ_SIZE;
+  RAD_SENSOR::RadSensorDataset dataset;
+  static const uint8_t MAX_CMD_LEN = RAD_SENSOR::READ_SIZE;
  GpioIF *gpioIF = nullptr;
  Stack5VHandler &stackHandler;

--- a/mission/payload/radSensorDefinitions.h
+++ b/mission/payload/radSensorDefinitions.h
@ -1,7 +1,7 @@
 #ifndef MISSION_DEVICES_DEVICEDEFINITIONS_RADSENSOR_H_
 #define MISSION_DEVICES_DEVICEDEFINITIONS_RADSENSOR_H_

-namespace radSens {
+namespace RAD_SENSOR {

 static const DeviceCommandId_t NONE = 0x0;  // Set when no command is pending

@ -78,6 +78,6 @@ class RadSensorDataset : public StaticLocalDataSet<DATASET_ENTRIES> {
  lp_var_t<uint16_t> ain6 = lp_var_t<uint16_t>(sid.objectId, AIN6, this);
  lp_var_t<uint16_t> ain7 = lp_var_t<uint16_t>(sid.objectId, AIN7, this);
 };
-}  // namespace radSens
+}  // namespace RAD_SENSOR

 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_RADSENSOR_H_ */
--- a/mission/pollingSeqTables.cpp
+++ b/mission/pollingSeqTables.cpp
@ -39,67 +39,56 @@ ReturnValue_t pst::pstSyrlinks(FixedTimeslotTaskIF *thisSequence) {

 // I don't think this needs to be in a PST because linux takes care of bus serialization, but
 // keep it like this for now, it works
-ReturnValue_t pst::pstI2c(TmpSchedConfig schedConf, FixedTimeslotTaskIF *thisSequence) {
+ReturnValue_t pst::pstI2cProcessingSystem(FixedTimeslotTaskIF *thisSequence) {
  // Length of a communication cycle
  uint32_t length = thisSequence->getPeriodMs();
  static_cast<void>(length);

-  if (schedConf.scheduleTmpDev0) {
-    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0, DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.1, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.1, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.1, DeviceHandlerIF::GET_READ);
-  }
+  // These are actually part of another bus, but this works, so keep it like this for now
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.2,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.2, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.2, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.3, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_0, length * 0.3, DeviceHandlerIF::GET_READ);

-  if (schedConf.scheduleTmpDev1) {
-    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.2,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.2,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.2, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.3, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.3, DeviceHandlerIF::GET_READ);
-  }
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.4, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.5, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_TCS_1, length * 0.5, DeviceHandlerIF::GET_READ);

-  if (schedConf.schedulePlPcduDev0) {
-    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.4,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.5,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.5,
-                          DeviceHandlerIF::GET_READ);
-  }
-  if (schedConf.schedulePlPcduDev1) {
-    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.6,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.6,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.6,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.7,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.7,
-                          DeviceHandlerIF::GET_READ);
-  }
-
-  if (schedConf.scheduleIfBoardDev) {
-    thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.9,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.9,
-                          DeviceHandlerIF::GET_READ);
-  }
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.6,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.6,
+                        DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.6,
+                        DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.7,
+                        DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_0, length * 0.7, DeviceHandlerIF::GET_READ);
+  // damaged
+  /*
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+                        DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+                        DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4,
+                        DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_PLPCDU_1, length * 0.4, DeviceHandlerIF::GET_READ);
+  */
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
+                        DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
+                        DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.8,
+                        DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.9,
+                        DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_IF_BOARD, length * 0.9, DeviceHandlerIF::GET_READ);
  static_cast<void>(length);
  return thisSequence->checkSequence();
 }
@ -591,6 +580,7 @@ ReturnValue_t pst::pstTcsAndAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg
  thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * config::spiSched::SCHED_BLOCK_9_PERIOD,
                        DeviceHandlerIF::GET_READ);

+#if OBSW_ADD_RAD_SENSORS == 1
  /* Radiation sensor */
  thisSequence->addSlot(objects::RAD_SENSOR, length * config::spiSched::SCHED_BLOCK_9_PERIOD,
                        DeviceHandlerIF::PERFORM_OPERATION);
@ -602,5 +592,6 @@ ReturnValue_t pst::pstTcsAndAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg
                        DeviceHandlerIF::SEND_READ);
  thisSequence->addSlot(objects::RAD_SENSOR, length * config::spiSched::SCHED_BLOCK_9_PERIOD,
                        DeviceHandlerIF::GET_READ);
+#endif
  return returnvalue::OK;
 }
--- a/mission/pollingSeqTables.h
+++ b/mission/pollingSeqTables.h
@ -39,16 +39,6 @@ struct AcsPstCfg {
  bool scheduleStr = true;
 };

-// Default config is for FM.
-struct TmpSchedConfig {
-  bool scheduleTmpDev0 = true;
-  bool scheduleTmpDev1 = true;
-  bool schedulePlPcduDev0 = true;
-  // damaged on FM
-  bool schedulePlPcduDev1 = false;
-  bool scheduleIfBoardDev = true;
-};
-
 /**
 * @brief	This function creates the PST for all gomspace devices.
 * @details
@ -61,7 +51,7 @@ ReturnValue_t pstSyrlinks(FixedTimeslotTaskIF* thisSequence);

 ReturnValue_t pstTcsAndAcs(FixedTimeslotTaskIF* thisSequence, AcsPstCfg cfg);

-ReturnValue_t pstI2c(TmpSchedConfig schedConf, FixedTimeslotTaskIF* thisSequence);
+ReturnValue_t pstI2cProcessingSystem(FixedTimeslotTaskIF* thisSequence);

 /**
 * Generic test PST
--- a/mission/power/P60DockHandler.cpp
+++ b/mission/power/P60DockHandler.cpp
@ -66,7 +66,7 @@ void P60DockHandler::parseHkTableReply(const uint8_t *packet) {
  }
  coreHk.battMode = newBattMode;

-  auxHk.heaterForBp4PackOn = *(packet + 0x57);
+  auxHk.heaterOn = *(packet + 0x57);
  auxHk.converter5VStatus = *(packet + 0x58);

  for (uint8_t idx = 0; idx < hk::CHNLS_LEN; idx++) {
@ -111,8 +111,6 @@ void P60DockHandler::parseHkTableReply(const uint8_t *packet) {
  }
  coreHk.setValidity(true, true);
  auxHk.setValidity(true, true);
-  // No BP4 pack, no this is always invalid.
-  auxHk.heaterForBp4PackOn.setValid(false);
 }

 ReturnValue_t P60DockHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
--- a/mission/power/gsDefs.h
+++ b/mission/power/gsDefs.h
@ -260,8 +260,7 @@ class HkTableDataset : public StaticLocalDataSet<32> {
  lp_var_t<uint16_t> resetcause = lp_var_t<uint16_t>(sid.objectId, pool::P60DOCK_RESETCAUSE, this);

  /** Battery heater control only possible on BP4 packs */
-  lp_var_t<uint8_t> heaterForBp4PackOn =
-      lp_var_t<uint8_t>(sid.objectId, pool::P60DOCK_HEATER_ON, this);
+  lp_var_t<uint8_t> heaterOn = lp_var_t<uint8_t>(sid.objectId, pool::P60DOCK_HEATER_ON, this);
  lp_var_t<uint8_t> converter5VStatus =
      lp_var_t<uint8_t>(sid.objectId, pool::P60DOCK_CONV_5V_ENABLE_STATUS, this);

--- a/mission/sysDefs.h
+++ b/mission/sysDefs.h
@ -34,9 +34,6 @@ enum Copy : int { COPY_0, COPY_1, NO_COPY, SELF_COPY, ALL_COPY };

 namespace core {

-extern std::atomic_bool SAVE_PUS_SEQUENCE_COUNT;
-extern std::atomic_bool SAVE_CFDP_SEQUENCE_COUNT;
-
 // TODO: Support for status? Or maybe some command to quickly get information whether a unit
 // is running.
 enum SystemctlCmd : uint8_t { START = 0, STOP = 1, RESTART = 2, NUM_CMDS = 3 };
@ -44,13 +41,9 @@ enum SystemctlCmd : uint8_t { START = 0, STOP = 1, RESTART = 2, NUM_CMDS = 3 };
 static constexpr char CONF_FOLDER[] = "conf";

 static constexpr char VERSION_FILE_NAME[] = "version.txt";
-static constexpr char LEGACY_REBOOT_WATCHDOG_FILE_NAME[] = "reboot.txt";
-static constexpr char REBOOT_WATCHDOG_FILE_NAME[] = "reboot_watchdog.txt";
-static constexpr char REBOOT_COUNTER_FILE_NAME[] = "reboot_counters.txt";
+static constexpr char REBOOT_FILE_NAME[] = "reboot.txt";
 static constexpr char TIME_FILE_NAME[] = "time_backup.txt";

-static constexpr uint32_t SYS_ROM_BASE_ADDR = 0x80000000;
-
 static constexpr ActionId_t ANNOUNCE_VERSION = 1;
 static constexpr ActionId_t ANNOUNCE_CURRENT_IMAGE = 2;
 static constexpr ActionId_t ANNOUNCE_BOOT_COUNTS = 3;
@ -58,7 +51,6 @@ static constexpr ActionId_t SWITCH_REBOOT_FILE_HANDLING = 5;
 static constexpr ActionId_t RESET_REBOOT_COUNTERS = 6;
 static constexpr ActionId_t SWITCH_IMG_LOCK = 7;
 static constexpr ActionId_t SET_MAX_REBOOT_CNT = 8;
-static constexpr ActionId_t READ_REBOOT_MECHANISM_INFO = 9;

 static constexpr ActionId_t OBSW_UPDATE_FROM_SD_0 = 10;
 static constexpr ActionId_t OBSW_UPDATE_FROM_SD_1 = 11;
@ -121,14 +113,6 @@ static constexpr Event TRYING_I2C_RECOVERY = event::makeEvent(SUBSYSTEM_ID, 10,
 static constexpr Event I2C_REBOOT = event::makeEvent(SUBSYSTEM_ID, 11, severity::HIGH);
 //! [EXPORT] : [COMMENT] PDEC recovery through reset was not possible, performing full reboot.
 static constexpr Event PDEC_REBOOT = event::makeEvent(SUBSYSTEM_ID, 12, severity::HIGH);
-//! [EXPORT] : [COMMENT] Version information of the firmware (not OBSW).
-//! P1: Byte 0: Major, Byte 1: Minor, Byte 2: Patch, Byte 3: Has Git Hash
-//! P2: First four letters of Git SHA is the last byte of P1 is set.
-static constexpr Event FIRMWARE_INFO = event::makeEvent(SUBSYSTEM_ID, 13, severity::INFO);
-//! [EXPORT] : [COMMENT] Active SD card info. SD States: 0: OFF, 1: ON, 2: MOUNTED.
-//! P1: Active SD Card Index, 0 if none is active
-//! P2: First two bytes: SD state of SD card 0, last two bytes SD state of SD card 1
-static constexpr Event ACTIVE_SD_INFO = event::makeEvent(SUBSYSTEM_ID, 14, severity::INFO);

 class ListDirectoryCmdBase {
 public:  // TODO: Packet definition for clean deserialization
@ -258,22 +242,19 @@ class CpHelperParser {
  CpHelperParser(const uint8_t* data, size_t maxLen) : data(data), maxLen(maxLen) {}

  ReturnValue_t parse() {
-    if (maxLen < 2) {
+    if (maxLen < 1) {
      return SerializeIF::STREAM_TOO_SHORT;
    }
    recursiveOpt = data[0];
-    forceOpt = data[1];
-    return parseDestTargetString(data + 2, maxLen - 2, destTgt);
+    return parseDestTargetString(data + 1, maxLen - 1, destTgt);
  }
  const SourceTargetPair& destTgtPair() const { return destTgt; }
  bool isRecursiveOptSet() const { return recursiveOpt; }
-  bool isForceOptSet() const { return forceOpt; }

 private:
  const uint8_t* data;
  size_t maxLen;
  bool recursiveOpt = false;
-  bool forceOpt = false;
  SourceTargetPair destTgt;
 };

--- a/mission/system/systemTree.cpp
+++ b/mission/system/systemTree.cpp
@ -31,12 +31,12 @@ void buildPtgInertialSequence(Subsystem& ss, ModeListEntry& eh);
 static const auto OFF = HasModesIF::MODE_OFF;
 static const auto NML = DeviceHandlerIF::MODE_NORMAL;

-void satsystem::init(bool commandPlPcdu1) {
+void satsystem::init() {
  auto& acsSubsystem = acs::init();
  acsSubsystem.connectModeTreeParent(EIVE_SYSTEM);
  auto& payloadSubsystem = payload::init();
  payloadSubsystem.connectModeTreeParent(EIVE_SYSTEM);
-  auto& tcsSubsystem = tcs::init(commandPlPcdu1);
+  auto& tcsSubsystem = tcs::init();
  tcsSubsystem.connectModeTreeParent(EIVE_SYSTEM);
  auto& comSubsystem = com::init();
  comSubsystem.connectModeTreeParent(EIVE_SYSTEM);
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Robin Mueller	3da8c781b9	afmt and bump patch All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details	2023-06-24 14:35:44 +02:00
Robin Mueller	5f08ca5408	sus convert bugfix All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details	2023-06-24 14:26:46 +02:00
Robin Mueller	88cb0d3382	changelog Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-06-24 14:26:13 +02:00
Robin Mueller	1e52c05150	remove printouts	2023-06-24 14:25:23 +02:00
Robin Mueller	17db795475	bugfix packet demux	2023-06-24 14:25:16 +02:00