prep v1.27.2

Merge pull request 'Enable ACS Controller to command RWs' (#375 ) from eggert/rw-cmd-acs-ctrl into develop
Reviewed-on: #375
2023-02-14 18:54:43 +01:00 · 2023-02-14 18:53:01 +01:00 · 2023-02-14 18:41:43 +01:00 · 2023-02-14 17:33:37 +01:00 · 2023-02-14 15:59:11 +01:00 · 2023-02-14 14:38:33 +01:00
70 changed files with 1226 additions and 475 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -17,6 +17,45 @@ change warranting a new major release:

 # [unreleased]

+# [v1.27.2] 2023-02-14
+
+Reaction Wheel handling was determined to be (quasi) broken and needs to be fixed in future release
+to be usable by ACS controller.
+
+eive-tmtc: v2.15.6
+
+## Added
+
+- Function for the ACS controller to command MTQ and RWs called by all subroutines
+- RwHandler now handles commanding of RW speeds via RwSpeedActuationSet
+- Tracing supports which allows checking whether threads are running as usual.
+
+## Changed
+
+- Remove 2 TCS threads.
+- Move low level polling into ACS PST, move high level device handlers into TCS system task.
+- ActCmds now returns command vectors as integers as required by the actuators
+  and scales them to the appropriate range
+- All RwHandler are now polled five times per ACS cycle
+- Remove 2 TCS threads. Move low level polling into ACS PST, move high level device handlers into
+  TCS system task.
+- Further reduce number of threads:
+  1. Remove PUS low priority task, move assigned threads to the generic system task
+  2. Group events and verification tasks into PUS high priority task
+  3. Group all other components into PUS medium priority task
+  4. Add SCEX device handler to PL task, remove dedicated thread
+
+## Removed
+
+- lwgps dependency not compiled anymore, is not used
+
+# [v1.27.1] 2023-02-13
+
+## Fixed
+
+- Fix for SPI ComIF: Set transfer size to 0 for failed transfers
+- Fix shadowing issue with locks in MAX31865 low level handler
+
 # [v1.27.0] 2023-02-13

 eive-tmtc: v2.12.5
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -11,7 +11,7 @@ cmake_minimum_required(VERSION 3.13)

 set(OBSW_VERSION_MAJOR 1)
 set(OBSW_VERSION_MINOR 27)
-set(OBSW_VERSION_REVISION 0)
+set(OBSW_VERSION_REVISION 2)

 # set(CMAKE_VERBOSE TRUE)

@ -424,7 +424,6 @@ add_subdirectory(${BSP_PATH})
 add_subdirectory(${COMMON_PATH})
 add_subdirectory(${DUMMY_PATH})

-add_subdirectory(${LIB_LWGPS_PATH})
 add_subdirectory(${FSFW_PATH})
 add_subdirectory(${LIB_EIVE_MISSION_PATH})
 add_subdirectory(${TEST_PATH})
@ -491,8 +490,8 @@ endif()
 # ##############################################################################

 # Add libraries
-target_link_libraries(${LIB_EIVE_MISSION}
-                      PUBLIC ${LIB_FSFW_NAME} ${LIB_LWGPS_NAME} ${LIB_OS_NAME})
+target_link_libraries(${LIB_EIVE_MISSION} PUBLIC ${LIB_FSFW_NAME}
+                                                 ${LIB_OS_NAME})

 target_link_libraries(${LIB_DUMMIES} PUBLIC ${LIB_FSFW_NAME} ${LIB_JSON_NAME})

--- a/bsp_hosted/ObjectFactory.cpp
+++ b/bsp_hosted/ObjectFactory.cpp
@ -62,7 +62,6 @@ void ObjectFactory::produce(void* args) {

  auto* dummyGpioIF = new DummyGpioIF();
  auto* dummySwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
-  static_cast<void>(dummyGpioIF);
 #ifdef PLATFORM_UNIX
  new SerialComIF(objects::UART_COM_IF);
 #if OBSW_ADD_PLOC_MPSOC == 1
@ -89,7 +88,7 @@ void ObjectFactory::produce(void* args) {
 #endif

  dummy::DummyCfg cfg;
-  dummy::createDummies(cfg, *dummySwitcher);
+  dummy::createDummies(cfg, *dummySwitcher, dummyGpioIF);

  HeaterHandler* heaterHandler = nullptr;
  // new ThermalController(objects::THERMAL_CONTROLLER);
--- a/bsp_q7s/core/CoreController.cpp
+++ b/bsp_q7s/core/CoreController.cpp
@ -63,6 +63,9 @@ ReturnValue_t CoreController::handleCommandMessage(CommandMessage *message) {
 }

 void CoreController::performControlOperation() {
+#if OBSW_THREAD_TRACING == 1
+  trace::threadTrace(opCounter, "CORE CTRL");
+#endif
  EventMessage event;
  for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == returnvalue::OK;
       result = eventQueue->receiveMessage(&event)) {
--- a/bsp_q7s/core/CoreController.h
+++ b/bsp_q7s/core/CoreController.h
@ -12,6 +12,7 @@
 #include "events/subsystemIdRanges.h"
 #include "fsfw/controller/ExtendedControllerBase.h"
 #include "mission/devices/devicedefinitions/GPSDefinitions.h"
+#include "mission/trace.h"

 class Timer;
 class SdCardManager;
@ -222,6 +223,9 @@ class CoreController : public ExtendedControllerBase {
  std::string currMntPrefix;
  bool performOneShotSdCardOpsSwitch = false;
  uint8_t shortSdCardCdCounter = 0;
+#if OBSW_THREAD_TRACING == 1
+  uint32_t opCounter;
+#endif
  Countdown sdCardCheckCd = Countdown(INIT_SD_CARD_CHECK_TIMEOUT);

  /**
--- a/bsp_q7s/core/ObjectFactory.cpp
+++ b/bsp_q7s/core/ObjectFactory.cpp
@ -239,10 +239,9 @@ ReturnValue_t ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF,
 }

 void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialComIF* uartComIF,
-                                             PowerSwitchIF* pwrSwitcher) {
+                                             PowerSwitchIF& pwrSwitcher) {
  using namespace gpio;
  GpioCookie* gpioCookieAcsBoard = new GpioCookie();
-  std::vector<std::reference_wrapper<DeviceHandlerBase>> assemblyChildren;

  std::stringstream consumer;
  GpiodRegularByLineName* gpio = nullptr;
@ -344,6 +343,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo

 #if OBSW_ADD_ACS_BOARD == 1
  std::string spiDev = q7s::SPI_DEFAULT_DEV;
+  std::array<DeviceHandlerBase*, 8> assemblyChildren;
  SpiCookie* spiCookie =
      new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
                    spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
@ -352,7 +352,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
      objects::MGM_0_LIS3_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::LIS3_TRANSITION_DELAY);
  fdir = new AcsBoardFdir(objects::MGM_0_LIS3_HANDLER);
  mgmLis3Handler0->setCustomFdir(fdir);
-  assemblyChildren.push_back(*mgmLis3Handler0);
+  assemblyChildren[0] = mgmLis3Handler0;
 #if OBSW_TEST_ACS == 1
  mgmLis3Handler->setStartUpImmediately();
  mgmLis3Handler->setToGoToNormalMode(true);
@ -369,7 +369,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
                           spi::RM3100_TRANSITION_DELAY);
  fdir = new AcsBoardFdir(objects::MGM_1_RM3100_HANDLER);
  mgmRm3100Handler1->setCustomFdir(fdir);
-  assemblyChildren.push_back(*mgmRm3100Handler1);
+  assemblyChildren[1] = mgmRm3100Handler1;
 #if OBSW_TEST_ACS == 1
  mgmRm3100Handler->setStartUpImmediately();
  mgmRm3100Handler->setToGoToNormalMode(true);
@ -385,7 +385,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
      objects::MGM_2_LIS3_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::LIS3_TRANSITION_DELAY);
  fdir = new AcsBoardFdir(objects::MGM_2_LIS3_HANDLER);
  mgmLis3Handler2->setCustomFdir(fdir);
-  assemblyChildren.push_back(*mgmLis3Handler2);
+  assemblyChildren[2] = mgmLis3Handler2;
 #if OBSW_TEST_ACS == 1
  mgmLis3Handler->setStartUpImmediately();
  mgmLis3Handler->setToGoToNormalMode(true);
@ -402,7 +402,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
                           spi::RM3100_TRANSITION_DELAY);
  fdir = new AcsBoardFdir(objects::MGM_3_RM3100_HANDLER);
  mgmRm3100Handler3->setCustomFdir(fdir);
-  assemblyChildren.push_back(*mgmRm3100Handler3);
+  assemblyChildren[3] = mgmRm3100Handler3;
 #if OBSW_TEST_ACS == 1
  mgmRm3100Handler->setStartUpImmediately();
  mgmRm3100Handler->setToGoToNormalMode(true);
@ -421,7 +421,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
                               ADIS1650X::Type::ADIS16505);
  fdir = new AcsBoardFdir(objects::GYRO_0_ADIS_HANDLER);
  adisHandler->setCustomFdir(fdir);
-  assemblyChildren.push_back(*adisHandler);
+  assemblyChildren[4] = adisHandler;
 #if OBSW_TEST_ACS == 1
  adisHandler->setStartUpImmediately();
  adisHandler->setToGoToNormalModeImmediately();
@ -437,7 +437,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
      objects::GYRO_1_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY);
  fdir = new AcsBoardFdir(objects::GYRO_1_L3G_HANDLER);
  gyroL3gHandler1->setCustomFdir(fdir);
-  assemblyChildren.push_back(*gyroL3gHandler1);
+  assemblyChildren[5] = gyroL3gHandler1;
 #if OBSW_TEST_ACS == 1
  gyroL3gHandler->setStartUpImmediately();
  gyroL3gHandler->setToGoToNormalMode(true);
@ -454,7 +454,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
                                         spiCookie, ADIS1650X::Type::ADIS16505);
  fdir = new AcsBoardFdir(objects::GYRO_2_ADIS_HANDLER);
  adisHandler->setCustomFdir(fdir);
-  assemblyChildren.push_back(*adisHandler);
+  assemblyChildren[6] = adisHandler;
 #if OBSW_TEST_ACS == 1
  adisHandler->setStartUpImmediately();
  adisHandler->setToGoToNormalModeImmediately();
@ -467,7 +467,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
      objects::GYRO_3_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY);
  fdir = new AcsBoardFdir(objects::GYRO_3_L3G_HANDLER);
  gyroL3gHandler3->setCustomFdir(fdir);
-  assemblyChildren.push_back(*gyroL3gHandler3);
+  assemblyChildren[7] = gyroL3gHandler3;
 #if OBSW_TEST_ACS == 1
  gyroL3gHandler->setStartUpImmediately();
  gyroL3gHandler->setToGoToNormalMode(true);
@ -485,22 +485,7 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialCo
      new GpsHyperionLinuxController(objects::GPS_CONTROLLER, objects::NO_OBJECT, debugGps);
  gpsCtrl->setResetPinTriggerFunction(gps::triggerGpioResetPin, &RESET_ARGS_GNSS);

-  AcsBoardHelper acsBoardHelper = AcsBoardHelper(
-      objects::MGM_0_LIS3_HANDLER, objects::MGM_1_RM3100_HANDLER, objects::MGM_2_LIS3_HANDLER,
-      objects::MGM_3_RM3100_HANDLER, objects::GYRO_0_ADIS_HANDLER, objects::GYRO_1_L3G_HANDLER,
-      objects::GYRO_2_ADIS_HANDLER, objects::GYRO_3_L3G_HANDLER, objects::GPS_CONTROLLER);
-  auto acsAss =
-      new AcsBoardAssembly(objects::ACS_BOARD_ASS, pwrSwitcher, acsBoardHelper, gpioComIF);
-  static_cast<void>(acsAss);
-  for (auto& assChild : assemblyChildren) {
-    ReturnValue_t result = assChild.get().connectModeTreeParent(*acsAss);
-    if (result != returnvalue::OK) {
-      sif::error << "Connecting assembly for ACS board component " << assChild.get().getObjectId()
-                 << " failed" << std::endl;
-    }
-  }
-  gpsCtrl->connectModeTreeParent(*acsAss);
-  acsAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
+  ObjectFactory::createAcsBoardAssy(pwrSwitcher, assemblyChildren, gpsCtrl, gpioComIF);
 #endif /* OBSW_ADD_ACS_HANDLERS == 1 */
 }

@ -692,33 +677,24 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF,
  std::array<object_id_t, 4> rwIds = {objects::RW1, objects::RW2, objects::RW3, objects::RW4};
  std::array<gpioId_t, 4> rwGpioIds = {gpioIds::EN_RW1, gpioIds::EN_RW2, gpioIds::EN_RW3,
                                       gpioIds::EN_RW4};
-  std::array<RwHandler*, 4> rws = {};
+  std::array<DeviceHandlerBase*, 4> rws = {};
  for (uint8_t idx = 0; idx < rwCookies.size(); idx++) {
    rwCookies[idx] = new SpiCookie(rwCookieParams[idx].first, rwCookieParams[idx].second,
                                   RwDefinitions::MAX_REPLY_SIZE, spi::RW_MODE, spi::RW_SPEED,
                                   &rwSpiCallback::spiCallback, nullptr);
-    rws[idx] = new RwHandler(rwIds[idx], objects::SPI_RW_COM_IF, rwCookies[idx], gpioComIF,
-                             rwGpioIds[idx]);
-    rwCookies[idx]->setCallbackArgs(rws[idx]);
+    auto* rwHandler = new RwHandler(rwIds[idx], objects::SPI_RW_COM_IF, rwCookies[idx], gpioComIF,
+                                    rwGpioIds[idx], idx);
+    rwCookies[idx]->setCallbackArgs(rwHandler);
 #if OBSW_TEST_RW == 1
    rws[idx]->setStartUpImmediately();
 #endif
 #if OBSW_DEBUG_RW == 1
-    rws[idx]->setDebugMode(true);
+    rwHandler->setDebugMode(true);
 #endif
+    rws[idx] = rwHandler;
  }

-  RwHelper rwHelper(rwIds);
-  auto* rwAss =
-      new RwAssembly(objects::RW_ASS, pwrSwitcher, pcdu::Switches::PDU2_CH2_RW_5V, rwHelper);
-  for (uint8_t idx = 0; idx < rws.size(); idx++) {
-    ReturnValue_t result = rws[idx]->connectModeTreeParent(*rwAss);
-    if (result != returnvalue::OK) {
-      sif::error << "Connecting RW " << static_cast<int>(idx) << " to RW assembly failed"
-                 << std::endl;
-    }
-  }
-  rwAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
+  createRwAssy(*pwrSwitcher, pcdu::Switches::PDU2_CH2_RW_5V, rws, rwIds);
 #endif /* OBSW_ADD_RW == 1 */
 }

--- a/bsp_q7s/core/ObjectFactory.h
+++ b/bsp_q7s/core/ObjectFactory.h
@ -33,7 +33,7 @@ void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
 void createTmpComponents();
 ReturnValue_t createRadSensorComponent(LinuxLibgpioIF* gpioComIF, Stack5VHandler& handler);
 void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, SerialComIF* uartComIF,
-                              PowerSwitchIF* pwrSwitcher);
+                              PowerSwitchIF& pwrSwitcher);
 void createHeaterComponents(GpioIF* gpioIF, PowerSwitchIF* pwrSwitcher, HealthTableIF* healthTable,
                            HeaterHandler*& heaterHandler);
 void createImtqComponents(PowerSwitchIF* pwrSwitcher);
--- a/bsp_q7s/core/scheduling.cpp
+++ b/bsp_q7s/core/scheduling.cpp
@ -154,6 +154,14 @@ void scheduling::initTasks() {
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("PL_SUBSYSTEM", objects::PL_SUBSYSTEM);
  }
+  result = genericSysTask->addComponent(objects::INTERNAL_ERROR_REPORTER);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
+  }
+  result = genericSysTask->addComponent(objects::PUS_SERVICE_17_TEST);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
+  }

 #if OBSW_ADD_CCSDS_IP_CORES == 1
  result = genericSysTask->addComponent(objects::CCSDS_HANDLER);
@ -214,31 +222,17 @@ void scheduling::initTasks() {
  }
 #endif

-#if OBSW_ADD_RTD_DEVICES == 1
-  PeriodicTaskIF* tcsPollingTask = factory->createPeriodicTask(
-      "TCS_POLLING_TASK", 75, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.5, missedDeadlineFunc);
-  result = tcsPollingTask->addComponent(objects::SPI_RTD_COM_IF);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("SPI_RTD_POLLING", objects::SPI_RTD_COM_IF);
-  }
-
-  PeriodicTaskIF* tcsTask = factory->createPeriodicTask(
-      "TCS_TASK", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
-  scheduling::scheduleRtdSensors(tcsTask);
-#endif
-
  PeriodicTaskIF* tcsSystemTask = factory->createPeriodicTask(
-      "TCS_TASK", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc);
+      "TCS_TASK", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.5, missedDeadlineFunc);
+  scheduling::scheduleRtdSensors(tcsSystemTask);
  result = tcsSystemTask->addComponent(objects::TCS_SUBSYSTEM);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("TCS_SUBSYSTEM", objects::TCS_SUBSYSTEM);
  }
-#if OBSW_ADD_RTD_DEVICES == 1
  result = tcsSystemTask->addComponent(objects::TCS_BOARD_ASS);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("TCS_BOARD_ASS", objects::TCS_BOARD_ASS);
  }
-#endif /* OBSW_ADD_RTD_DEVICES */
 #if OBSW_ADD_TCS_CTRL == 1
  result = tcsSystemTask->addComponent(objects::THERMAL_CONTROLLER);
  if (result != returnvalue::OK) {
@ -280,14 +274,16 @@ void scheduling::initTasks() {
 #endif /* OBSW_ADD_PLOC_SUPERVISOR */

  PeriodicTaskIF* plTask = factory->createPeriodicTask(
-      "PL_TASK", 25, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.0, missedDeadlineFunc);
-  scheduling::addMpsocSupvHandlers(plTask);
+      "PL_TASK", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
  plTask->addComponent(objects::CAM_SWITCHER);
+  scheduling::addMpsocSupvHandlers(plTask);
+#if OBSW_ADD_SCEX_DEVICE == 1
+  scheduling::scheduleScexDev(plTask);
+#endif

 #if OBSW_ADD_SCEX_DEVICE == 1
-  PeriodicTaskIF* scexDevHandler;
  PeriodicTaskIF* scexReaderTask;
-  scheduling::schedulingScex(*factory, scexDevHandler, scexReaderTask);
+  scheduling::scheduleScexReader(*factory, scexReaderTask);
 #endif

  std::vector<PeriodicTaskIF*> pusTasks;
@ -344,7 +340,6 @@ void scheduling::initTasks() {
  taskStarter(pstTasks, "PST task vector");
  taskStarter(pusTasks, "PUS task vector");
 #if OBSW_ADD_SCEX_DEVICE == 1
-  scexDevHandler->startTask();
  scexReaderTask->startTask();
 #endif

@ -364,10 +359,6 @@ void scheduling::initTasks() {
  gpsTask->startTask();
 #endif
  acsSysTask->startTask();
-#if OBSW_ADD_RTD_DEVICES == 1
-  tcsPollingTask->startTask();
-  tcsTask->startTask();
-#endif /* OBSW_ADD_RTD_DEVICES == 1 */
  if (not tcsSystemTask->isEmpty()) {
    tcsSystemTask->startTask();
  }
@ -392,9 +383,9 @@ void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction
 #else
  static constexpr float acsPstPeriod = 0.8;
 #endif
-  FixedTimeslotTaskIF* acsPst = factory.createFixedTimeslotTask(
-      "ACS_PST", 85, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, acsPstPeriod, missedDeadlineFunc);
-  result = pst::pstAcs(acsPst, cfg);
+  FixedTimeslotTaskIF* acsTcsPst = factory.createFixedTimeslotTask(
+      "ACS_TCS_PST", 85, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, acsPstPeriod, missedDeadlineFunc);
+  result = pst::pstTcsAndAcs(acsTcsPst, cfg);
  if (result != returnvalue::OK) {
    if (result == FixedTimeslotTaskIF::SLOT_LIST_EMPTY) {
      sif::warning << "scheduling::initTasks: ACS PST is empty" << std::endl;
@ -402,7 +393,7 @@ void scheduling::createPstTasks(TaskFactory& factory, TaskDeadlineMissedFunction
      sif::error << "scheduling::initTasks: Creating ACS PST failed!" << std::endl;
    }
  } else {
-    taskVec.push_back(acsPst);
+    taskVec.push_back(acsTcsPst);
  }

  /* Polling Sequence Table Default */
@ -453,42 +444,28 @@ void scheduling::createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction
                                std::vector<PeriodicTaskIF*>& taskVec) {
  ReturnValue_t result = returnvalue::OK;
  /* PUS Services */
-  PeriodicTaskIF* pusVerification = factory.createPeriodicTask(
-      "PUS_VERIF", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
-  result = pusVerification->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
+  PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
+      "PUS_HIGH_PRIO", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_1_VERIFICATION);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("PUS_VERIF", objects::PUS_SERVICE_1_VERIFICATION);
  }
-  taskVec.push_back(pusVerification);
-
-  PeriodicTaskIF* pusEvents = factory.createPeriodicTask(
-      "PUS_EVENTS", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.200, missedDeadlineFunc);
-  result = pusEvents->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
+  result = pusHighPrio->addComponent(objects::PUS_SERVICE_5_EVENT_REPORTING);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("PUS_EVENTS", objects::PUS_SERVICE_5_EVENT_REPORTING);
  }
-  result = pusEvents->addComponent(objects::EVENT_MANAGER);
+  result = pusHighPrio->addComponent(objects::EVENT_MANAGER);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("PUS_MGMT", objects::EVENT_MANAGER);
  }
-  taskVec.push_back(pusEvents);
-
-  PeriodicTaskIF* pusHighPrio = factory.createPeriodicTask(
-      "PUS_HIGH_PRIO", 50, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
-  result = pusHighPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
-  }
  result = pusHighPrio->addComponent(objects::PUS_SERVICE_9_TIME_MGMT);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("PUS_9", objects::PUS_SERVICE_9_TIME_MGMT);
  }
-
  taskVec.push_back(pusHighPrio);

  PeriodicTaskIF* pusMedPrio = factory.createPeriodicTask(
      "PUS_MED_PRIO", 40, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.8, missedDeadlineFunc);
-
  result = pusMedPrio->addComponent(objects::PUS_SERVICE_3_HOUSEKEEPING);
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("PUS_3", objects::PUS_SERVICE_3_HOUSEKEEPING);
@ -513,20 +490,11 @@ void scheduling::createPusTasks(TaskFactory& factory, TaskDeadlineMissedFunction
  if (result != returnvalue::OK) {
    scheduling::printAddObjectError("PUS_201", objects::PUS_SERVICE_201_HEALTH);
  }
-  // Used for connection tests, therefore use higher priority
-  result = pusMedPrio->addComponent(objects::PUS_SERVICE_17_TEST);
+  result = pusMedPrio->addComponent(objects::PUS_SERVICE_2_DEVICE_ACCESS);
  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("PUS_17", objects::PUS_SERVICE_17_TEST);
+    scheduling::printAddObjectError("PUS_2", objects::PUS_SERVICE_2_DEVICE_ACCESS);
  }
  taskVec.push_back(pusMedPrio);
-
-  PeriodicTaskIF* pusLowPrio = factory.createPeriodicTask(
-      "PUS_LOW_PRIO", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE, 1.6, missedDeadlineFunc);
-  result = pusLowPrio->addComponent(objects::INTERNAL_ERROR_REPORTER);
-  if (result != returnvalue::OK) {
-    scheduling::printAddObjectError("ERROR_REPORTER", objects::INTERNAL_ERROR_REPORTER);
-  }
-  taskVec.push_back(pusLowPrio);
 }

 void scheduling::createTestTasks(TaskFactory& factory,
--- a/bsp_q7s/em/emObjectFactory.cpp
+++ b/bsp_q7s/em/emObjectFactory.cpp
@ -2,6 +2,7 @@
 #include <fsfw/health/HealthTableIF.h>
 #include <fsfw/power/DummyPowerSwitcher.h>
 #include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
+#include <mission/system/tree/system.h>

 #include "OBSWConfig.h"
 #include "bsp_q7s/core/CoreController.h"
@ -54,7 +55,7 @@ void ObjectFactory::produce(void* args) {
  createPcduComponents(gpioComIF, &pwrSwitcher);
 #endif

-  dummy::createDummies(dummyCfg, *pwrSwitcher);
+  dummy::createDummies(dummyCfg, *pwrSwitcher, gpioComIF);

  new CoreController(objects::CORE_CONTROLLER);

@ -74,7 +75,7 @@ void ObjectFactory::produce(void* args) {
  // createRadSensorComponent(gpioComIF);

 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(gpioComIF, uartComIF, pwrSwitcher);
+  createAcsBoardComponents(gpioComIF, uartComIF, *pwrSwitcher);
 #endif

 #if OBSW_ADD_MGT == 1
@ -115,5 +116,5 @@ void ObjectFactory::produce(void* args) {
  HeaterHandler* heaterHandler = nullptr;
  ObjectFactory::createGenericHeaterComponents(*gpioComIF, *pwrSwitcher, heaterHandler);
  createThermalController(*heaterHandler);
-  satsystem::com::init();
+  satsystem::init();
 }
--- a/bsp_q7s/fmObjectFactory.cpp
+++ b/bsp_q7s/fmObjectFactory.cpp
@ -39,11 +39,11 @@ void ObjectFactory::produce(void* args) {
  createRadSensorComponent(gpioComIF, *stackHandler);
 #endif
 #if OBSW_ADD_SUN_SENSORS == 1
-  createSunSensorComponents(gpioComIF, spiMainComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV, true);
+  createSunSensorComponents(gpioComIF, spiMainComIF, *pwrSwitcher, q7s::SPI_DEFAULT_DEV, true);
 #endif

 #if OBSW_ADD_ACS_BOARD == 1
-  createAcsBoardComponents(gpioComIF, uartComIF, pwrSwitcher);
+  createAcsBoardComponents(gpioComIF, uartComIF, *pwrSwitcher);
 #endif
  HeaterHandler* heaterHandler;
  createHeaterComponents(gpioComIF, pwrSwitcher, healthTable, heaterHandler);
--- a/dummies/CMakeLists.txt
+++ b/dummies/CMakeLists.txt
@ -14,12 +14,16 @@ target_sources(
         PduDummy.cpp
         P60DockDummy.cpp
         SaDeploymentDummy.cpp
-         GpsDummy.cpp
+         GpsDhbDummy.cpp
+         GpsCtrlDummy.cpp
         GyroAdisDummy.cpp
         GyroL3GD20Dummy.cpp
         MgmLIS3MDLDummy.cpp
         PlPcduDummy.cpp
+         ScexDummy.cpp
         CoreControllerDummy.cpp
+         PlocMpsocDummy.cpp
+         PlocSupervisorDummy.cpp
         helpers.cpp
         MgmRm3100Dummy.cpp
         Tmp1075Dummy.cpp)
--- a/dummies/GpsCtrlDummy.cpp
+++ b/dummies/GpsCtrlDummy.cpp
@ -0,0 +1,21 @@
+#include "GpsCtrlDummy.h"
+
+GpsCtrlDummy::GpsCtrlDummy(object_id_t objectId) : ExtendedControllerBase(objectId, 20) {}
+
+ReturnValue_t GpsCtrlDummy::handleCommandMessage(CommandMessage* message) {
+  return returnvalue::OK;
+}
+
+void GpsCtrlDummy::performControlOperation() {}
+
+ReturnValue_t GpsCtrlDummy::checkModeCommand(Mode_t mode, Submode_t submode,
+                                             uint32_t* msToReachTheMode) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t GpsCtrlDummy::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                                    LocalDataPoolManager& poolManager) {
+  return returnvalue::OK;
+}
+
+LocalPoolDataSetBase* GpsCtrlDummy::getDataSetHandle(sid_t sid) { return nullptr; }
--- a/dummies/GpsCtrlDummy.h
+++ b/dummies/GpsCtrlDummy.h
@ -0,0 +1,20 @@
+#ifndef DUMMIES_GPSCTRLDUMMY_H_
+#define DUMMIES_GPSCTRLDUMMY_H_
+
+#include <fsfw/controller/ExtendedControllerBase.h>
+
+class GpsCtrlDummy : public ExtendedControllerBase {
+ public:
+  GpsCtrlDummy(object_id_t objectId);
+
+ private:
+  ReturnValue_t handleCommandMessage(CommandMessage* message) override;
+  void performControlOperation() override;
+  ReturnValue_t checkModeCommand(Mode_t mode, Submode_t submode,
+                                 uint32_t* msToReachTheMode) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                        LocalDataPoolManager& poolManager) override;
+  LocalPoolDataSetBase* getDataSetHandle(sid_t sid) override;
+};
+
+#endif /* DUMMIES_GPSCTRLDUMMY_H_ */
--- a/dummies/GpsDhbDummy.cpp
+++ b/dummies/GpsDhbDummy.cpp
@ -1,42 +1,44 @@
-#include "GpsDummy.h"
-
+#include <dummies/GpsDhbDummy.h>
 #include <mission/devices/devicedefinitions/GPSDefinitions.h>

-GpsDummy::GpsDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+GpsDhbDummy::GpsDhbDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
    : DeviceHandlerBase(objectId, comif, comCookie) {}

-GpsDummy::~GpsDummy() {}
+GpsDhbDummy::~GpsDhbDummy() {}

-void GpsDummy::doStartUp() {}
+void GpsDhbDummy::doStartUp() {}

-void GpsDummy::doShutDown() {}
+void GpsDhbDummy::doShutDown() {}

-ReturnValue_t GpsDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
-
-ReturnValue_t GpsDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+ReturnValue_t GpsDhbDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
  return NOTHING_TO_SEND;
 }

-ReturnValue_t GpsDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                const uint8_t *commandData, size_t commandDataLen) {
+ReturnValue_t GpsDhbDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t GpsDhbDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                   const uint8_t *commandData,
+                                                   size_t commandDataLen) {
  return returnvalue::OK;
 }

-ReturnValue_t GpsDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
-                                     size_t *foundLen) {
+ReturnValue_t GpsDhbDummy::scanForReply(const uint8_t *start, size_t len,
+                                        DeviceCommandId_t *foundId, size_t *foundLen) {
  return returnvalue::OK;
 }

-ReturnValue_t GpsDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+ReturnValue_t GpsDhbDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
  return returnvalue::OK;
 }

-void GpsDummy::fillCommandAndReplyMap() {}
+void GpsDhbDummy::fillCommandAndReplyMap() {}

-uint32_t GpsDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+uint32_t GpsDhbDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }

-ReturnValue_t GpsDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                                LocalDataPoolManager &poolManager) {
+ReturnValue_t GpsDhbDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                   LocalDataPoolManager &poolManager) {
  localDataPoolMap.emplace(GpsHyperion::LATITUDE, new PoolEntry<double>({0.0}, 1));
  localDataPoolMap.emplace(GpsHyperion::LONGITUDE, new PoolEntry<double>({0.0}, 1));
  localDataPoolMap.emplace(GpsHyperion::ALTITUDE, new PoolEntry<double>({0.0}));
--- a/dummies/GpsDhbDummy.h
+++ b/dummies/GpsDhbDummy.h
@ -0,0 +1,33 @@
+#ifndef DUMMIES_GPSDHBDUMMY_H_
+#define DUMMIES_GPSDHBDUMMY_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class GpsDhbDummy : 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;
+
+  GpsDhbDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~GpsDhbDummy();
+
+ protected:
+  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;
+};
+
+#endif /* DUMMIES_GPSDHBDUMMY_H_ */
--- a/dummies/PlocMpsocDummy.cpp
+++ b/dummies/PlocMpsocDummy.cpp
@ -0,0 +1,42 @@
+#include "PlocMpsocDummy.h"
+
+PlocMpsocDummy::PlocMpsocDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+PlocMpsocDummy::~PlocMpsocDummy() {}
+
+void PlocMpsocDummy::doStartUp() {}
+
+void PlocMpsocDummy::doShutDown() {}
+
+ReturnValue_t PlocMpsocDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PlocMpsocDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PlocMpsocDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                      const uint8_t *commandData,
+                                                      size_t commandDataLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocDummy::scanForReply(const uint8_t *start, size_t len,
+                                           DeviceCommandId_t *foundId, size_t *foundLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return returnvalue::OK;
+}
+
+void PlocMpsocDummy::fillCommandAndReplyMap() {}
+
+uint32_t PlocMpsocDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t PlocMpsocDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                      LocalDataPoolManager &poolManager) {
+  return returnvalue::OK;
+}
--- a/dummies/PlocMpsocDummy.h
+++ b/dummies/PlocMpsocDummy.h
@ -1,9 +1,8 @@
-#ifndef DUMMIES_GPSDUMMY_H_
-#define DUMMIES_GPSDUMMY_H_
+#pragma once

 #include <fsfw/devicehandlers/DeviceHandlerBase.h>

-class GpsDummy : public DeviceHandlerBase {
+class PlocMpsocDummy : public DeviceHandlerBase {
 public:
  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
  static const DeviceCommandId_t PERIODIC_REPLY = 2;
@ -11,8 +10,8 @@ class GpsDummy : public DeviceHandlerBase {
  static const uint8_t SIMPLE_COMMAND_DATA = 1;
  static const uint8_t PERIODIC_REPLY_DATA = 2;

-  GpsDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
-  virtual ~GpsDummy();
+  PlocMpsocDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~PlocMpsocDummy();

 protected:
  void doStartUp() override;
@ -29,5 +28,3 @@ class GpsDummy : public DeviceHandlerBase {
  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                        LocalDataPoolManager &poolManager) override;
 };
-
-#endif /* DUMMIES_GPSDUMMY_H_ */
--- a/dummies/PlocSupervisorDummy.cpp
+++ b/dummies/PlocSupervisorDummy.cpp
@ -0,0 +1,44 @@
+#include "PlocSupervisorDummy.h"
+
+PlocSupervisorDummy::PlocSupervisorDummy(object_id_t objectId, object_id_t comif,
+                                         CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+PlocSupervisorDummy::~PlocSupervisorDummy() {}
+
+void PlocSupervisorDummy::doStartUp() {}
+
+void PlocSupervisorDummy::doShutDown() {}
+
+ReturnValue_t PlocSupervisorDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PlocSupervisorDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PlocSupervisorDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                           const uint8_t *commandData,
+                                                           size_t commandDataLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocSupervisorDummy::scanForReply(const uint8_t *start, size_t len,
+                                                DeviceCommandId_t *foundId, size_t *foundLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocSupervisorDummy::interpretDeviceReply(DeviceCommandId_t id,
+                                                        const uint8_t *packet) {
+  return returnvalue::OK;
+}
+
+void PlocSupervisorDummy::fillCommandAndReplyMap() {}
+
+uint32_t PlocSupervisorDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t PlocSupervisorDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                           LocalDataPoolManager &poolManager) {
+  return returnvalue::OK;
+}
--- a/dummies/PlocSupervisorDummy.h
+++ b/dummies/PlocSupervisorDummy.h
@ -0,0 +1,30 @@
+#pragma once
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class PlocSupervisorDummy : 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;
+
+  PlocSupervisorDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~PlocSupervisorDummy();
+
+ protected:
+  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;
+};
--- a/dummies/ScexDummy.cpp
+++ b/dummies/ScexDummy.cpp
@ -0,0 +1,40 @@
+#include "ScexDummy.h"
+
+ScexDummy::ScexDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+ScexDummy::~ScexDummy() {}
+
+void ScexDummy::doStartUp() {}
+
+void ScexDummy::doShutDown() {}
+
+ReturnValue_t ScexDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) { return NOTHING_TO_SEND; }
+
+ReturnValue_t ScexDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t ScexDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                 const uint8_t *commandData,
+                                                 size_t commandDataLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t ScexDummy::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                                      size_t *foundLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t ScexDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return returnvalue::OK;
+}
+
+void ScexDummy::fillCommandAndReplyMap() {}
+
+uint32_t ScexDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t ScexDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                 LocalDataPoolManager &poolManager) {
+  return returnvalue::OK;
+}
--- a/dummies/ScexDummy.h
+++ b/dummies/ScexDummy.h
@ -0,0 +1,30 @@
+#pragma once
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class ScexDummy : 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;
+
+  ScexDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~ScexDummy();
+
+ protected:
+  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;
+};
--- a/dummies/helpers.cpp
+++ b/dummies/helpers.cpp
@ -5,7 +5,8 @@
 #include <dummies/ComCookieDummy.h>
 #include <dummies/ComIFDummy.h>
 #include <dummies/CoreControllerDummy.h>
-#include <dummies/GpsDummy.h>
+#include <dummies/GpsCtrlDummy.h>
+#include <dummies/GpsDhbDummy.h>
 #include <dummies/GyroAdisDummy.h>
 #include <dummies/GyroL3GD20Dummy.h>
 #include <dummies/ImtqDummy.h>
@ -14,20 +15,29 @@
 #include <dummies/P60DockDummy.h>
 #include <dummies/PduDummy.h>
 #include <dummies/PlPcduDummy.h>
+#include <dummies/PlocMpsocDummy.h>
+#include <dummies/PlocSupervisorDummy.h>
 #include <dummies/RwDummy.h>
 #include <dummies/SaDeploymentDummy.h>
+#include <dummies/ScexDummy.h>
 #include <dummies/StarTrackerDummy.h>
 #include <dummies/SusDummy.h>
 #include <dummies/SyrlinksDummy.h>
+#include <fsfw_hal/common/gpio/GpioIF.h>
 #include <mission/system/objects/CamSwitcher.h>
+#include <mission/system/objects/TcsBoardAssembly.h>

 #include "TemperatureSensorInserter.h"
 #include "dummies/Max31865Dummy.h"
 #include "dummies/Tmp1075Dummy.h"
+#include "mission/core/GenericFactory.h"
+#include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
+#include "mission/system/tree/acsModeTree.h"
+#include "mission/system/tree/comModeTree.h"
+#include "mission/system/tree/payloadModeTree.h"
+#include "mission/system/tree/tcsModeTree.h"

-using namespace dummy;
-
-void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch) {
+void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpioIF) {
  new ComIFDummy(objects::DUMMY_COM_IF);
  auto* comCookieDummy = new ComCookieDummy();
  new BpxDummy(objects::BPX_BATT_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
@ -37,17 +47,25 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch) {
  if (cfg.addRtdComIFDummy) {
    new ComIFDummy(objects::SPI_RTD_COM_IF);
  }
-  new RwDummy(objects::RW1, objects::DUMMY_COM_IF, comCookieDummy);
-  new RwDummy(objects::RW2, objects::DUMMY_COM_IF, comCookieDummy);
-  new RwDummy(objects::RW3, objects::DUMMY_COM_IF, comCookieDummy);
-  new RwDummy(objects::RW4, objects::DUMMY_COM_IF, comCookieDummy);
+  std::array<object_id_t, 4> rwIds = {objects::RW1, objects::RW2, objects::RW3, objects::RW4};
+  std::array<DeviceHandlerBase*, 4> rws;
+  rws[0] = new RwDummy(objects::RW1, objects::DUMMY_COM_IF, comCookieDummy);
+  rws[1] = new RwDummy(objects::RW2, objects::DUMMY_COM_IF, comCookieDummy);
+  rws[2] = new RwDummy(objects::RW3, objects::DUMMY_COM_IF, comCookieDummy);
+  rws[3] = new RwDummy(objects::RW4, objects::DUMMY_COM_IF, comCookieDummy);
+  ObjectFactory::createRwAssy(pwrSwitcher, pcdu::Switches::PDU2_CH2_RW_5V, rws, rwIds);
  new SaDeplDummy(objects::SOLAR_ARRAY_DEPL_HANDLER);
-  new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
+  auto* strDummy =
+      new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
+  strDummy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
  if (cfg.addSyrlinksDummies) {
-    new SyrlinksDummy(objects::SYRLINKS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    auto* syrlinksDummy =
+        new SyrlinksDummy(objects::SYRLINKS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    syrlinksDummy->connectModeTreeParent(satsystem::com::SUBSYSTEM);
  }
  auto* imtqDummy = new ImtqDummy(objects::IMTQ_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
  imtqDummy->enableThermalModule(ThermalStateCfg());
+  imtqDummy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
  if (cfg.addPowerDummies) {
    new AcuDummy(objects::ACU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
    new PduDummy(objects::PDU1_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
@ -56,103 +74,147 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch) {
  }

  if (cfg.addAcsBoardDummies) {
-    new GyroAdisDummy(objects::GYRO_0_ADIS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-    new GyroL3GD20Dummy(objects::GYRO_1_L3G_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-    new GyroAdisDummy(objects::GYRO_2_ADIS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-    new GyroL3GD20Dummy(objects::GYRO_3_L3G_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-    new MgmLIS3MDLDummy(objects::MGM_0_LIS3_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-    new MgmLIS3MDLDummy(objects::MGM_2_LIS3_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-    new MgmRm3100Dummy(objects::MGM_1_RM3100_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-    new MgmRm3100Dummy(objects::MGM_3_RM3100_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-    new GpsDummy(objects::GPS_CONTROLLER, objects::DUMMY_COM_IF, comCookieDummy);
+    std::array<DeviceHandlerBase*, 8> assemblyDhbs;
+    assemblyDhbs[0] =
+        new MgmLIS3MDLDummy(objects::MGM_0_LIS3_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    assemblyDhbs[1] =
+        new MgmLIS3MDLDummy(objects::MGM_2_LIS3_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    assemblyDhbs[2] =
+        new MgmRm3100Dummy(objects::MGM_1_RM3100_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    assemblyDhbs[3] =
+        new MgmRm3100Dummy(objects::MGM_3_RM3100_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    assemblyDhbs[4] =
+        new GyroAdisDummy(objects::GYRO_0_ADIS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    assemblyDhbs[5] =
+        new GyroL3GD20Dummy(objects::GYRO_1_L3G_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    assemblyDhbs[6] =
+        new GyroAdisDummy(objects::GYRO_2_ADIS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    assemblyDhbs[7] =
+        new GyroL3GD20Dummy(objects::GYRO_3_L3G_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    auto* gpsCtrl = new GpsCtrlDummy(objects::GPS_CONTROLLER);
+    ObjectFactory::createAcsBoardAssy(pwrSwitcher, assemblyDhbs, gpsCtrl, gpioIF);
  }

  if (cfg.addSusDummies) {
-    new SusDummy(objects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::DUMMY_COM_IF, comCookieDummy);
-    new SusDummy(objects::SUS_1_N_LOC_XBYFZM_PT_XB, objects::DUMMY_COM_IF, comCookieDummy);
-    new SusDummy(objects::SUS_2_N_LOC_XFYBZB_PT_YB, objects::DUMMY_COM_IF, comCookieDummy);
-    new SusDummy(objects::SUS_3_N_LOC_XFYBZF_PT_YF, objects::DUMMY_COM_IF, comCookieDummy);
-    new SusDummy(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, objects::DUMMY_COM_IF, comCookieDummy);
-    new SusDummy(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, objects::DUMMY_COM_IF, comCookieDummy);
-    new SusDummy(objects::SUS_6_R_LOC_XFYBZM_PT_XF, objects::DUMMY_COM_IF, comCookieDummy);
-    new SusDummy(objects::SUS_7_R_LOC_XBYBZM_PT_XB, objects::DUMMY_COM_IF, comCookieDummy);
-    new SusDummy(objects::SUS_8_R_LOC_XBYBZB_PT_YB, objects::DUMMY_COM_IF, comCookieDummy);
-    new SusDummy(objects::SUS_9_R_LOC_XBYBZB_PT_YF, objects::DUMMY_COM_IF, comCookieDummy);
-    new SusDummy(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, objects::DUMMY_COM_IF, comCookieDummy);
-    new SusDummy(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, objects::DUMMY_COM_IF, comCookieDummy);
+    std::array<DeviceHandlerBase*, 12> suses;
+    suses[0] =
+        new SusDummy(objects::SUS_0_N_LOC_XFYFZM_PT_XF, objects::DUMMY_COM_IF, comCookieDummy);
+    suses[1] =
+        new SusDummy(objects::SUS_1_N_LOC_XBYFZM_PT_XB, objects::DUMMY_COM_IF, comCookieDummy);
+    suses[2] =
+        new SusDummy(objects::SUS_2_N_LOC_XFYBZB_PT_YB, objects::DUMMY_COM_IF, comCookieDummy);
+    suses[3] =
+        new SusDummy(objects::SUS_3_N_LOC_XFYBZF_PT_YF, objects::DUMMY_COM_IF, comCookieDummy);
+    suses[4] =
+        new SusDummy(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, objects::DUMMY_COM_IF, comCookieDummy);
+    suses[5] =
+        new SusDummy(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, objects::DUMMY_COM_IF, comCookieDummy);
+    suses[6] =
+        new SusDummy(objects::SUS_6_R_LOC_XFYBZM_PT_XF, objects::DUMMY_COM_IF, comCookieDummy);
+    suses[7] =
+        new SusDummy(objects::SUS_7_R_LOC_XBYBZM_PT_XB, objects::DUMMY_COM_IF, comCookieDummy);
+    suses[8] =
+        new SusDummy(objects::SUS_8_R_LOC_XBYBZB_PT_YB, objects::DUMMY_COM_IF, comCookieDummy);
+    suses[9] =
+        new SusDummy(objects::SUS_9_R_LOC_XBYBZB_PT_YF, objects::DUMMY_COM_IF, comCookieDummy);
+    suses[10] =
+        new SusDummy(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, objects::DUMMY_COM_IF, comCookieDummy);
+    suses[11] =
+        new SusDummy(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, objects::DUMMY_COM_IF, comCookieDummy);
+    ObjectFactory::createSusAssy(pwrSwitcher, suses);
  }

  if (cfg.addTempSensorDummies) {
-    std::map<object_id_t, Max31865Dummy*> tempSensorDummies;
-    tempSensorDummies.emplace(objects::RTD_0_IC3_PLOC_HEATSPREADER,
-                              new Max31865Dummy(objects::RTD_0_IC3_PLOC_HEATSPREADER,
-                                                objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(objects::RTD_1_IC4_PLOC_MISSIONBOARD,
-                              new Max31865Dummy(objects::RTD_1_IC4_PLOC_MISSIONBOARD,
-                                                objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    std::map<object_id_t, Max31865Dummy*> rtdSensorDummies;
+    rtdSensorDummies.emplace(objects::RTD_0_IC3_PLOC_HEATSPREADER,
+                             new Max31865Dummy(objects::RTD_0_IC3_PLOC_HEATSPREADER,
+                                               objects::DUMMY_COM_IF, comCookieDummy));
+    rtdSensorDummies.emplace(objects::RTD_1_IC4_PLOC_MISSIONBOARD,
+                             new Max31865Dummy(objects::RTD_1_IC4_PLOC_MISSIONBOARD,
+                                               objects::DUMMY_COM_IF, comCookieDummy));
+    rtdSensorDummies.emplace(
        objects::RTD_2_IC5_4K_CAMERA,
        new Max31865Dummy(objects::RTD_2_IC5_4K_CAMERA, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(objects::RTD_3_IC6_DAC_HEATSPREADER,
-                              new Max31865Dummy(objects::RTD_3_IC6_DAC_HEATSPREADER,
-                                                objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(objects::RTD_3_IC6_DAC_HEATSPREADER,
+                             new Max31865Dummy(objects::RTD_3_IC6_DAC_HEATSPREADER,
+                                               objects::DUMMY_COM_IF, comCookieDummy));
+    rtdSensorDummies.emplace(
        objects::RTD_4_IC7_STARTRACKER,
        new Max31865Dummy(objects::RTD_4_IC7_STARTRACKER, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
        objects::RTD_5_IC8_RW1_MX_MY,
        new Max31865Dummy(objects::RTD_5_IC8_RW1_MX_MY, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
        objects::RTD_6_IC9_DRO,
        new Max31865Dummy(objects::RTD_6_IC9_DRO, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
        objects::RTD_7_IC10_SCEX,
        new Max31865Dummy(objects::RTD_7_IC10_SCEX, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
        objects::RTD_8_IC11_X8,
        new Max31865Dummy(objects::RTD_8_IC11_X8, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
        objects::RTD_9_IC12_HPA,
        new Max31865Dummy(objects::RTD_9_IC12_HPA, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
        objects::RTD_10_IC13_PL_TX,
        new Max31865Dummy(objects::RTD_10_IC13_PL_TX, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
        objects::RTD_11_IC14_MPA,
        new Max31865Dummy(objects::RTD_11_IC14_MPA, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
        objects::RTD_12_IC15_ACU,
        new Max31865Dummy(objects::RTD_12_IC15_ACU, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(objects::RTD_13_IC16_PLPCDU_HEATSPREADER,
-                              new Max31865Dummy(objects::RTD_13_IC16_PLPCDU_HEATSPREADER,
-                                                objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(objects::RTD_13_IC16_PLPCDU_HEATSPREADER,
+                             new Max31865Dummy(objects::RTD_13_IC16_PLPCDU_HEATSPREADER,
+                                               objects::DUMMY_COM_IF, comCookieDummy));
+    rtdSensorDummies.emplace(
        objects::RTD_14_IC17_TCS_BOARD,
        new Max31865Dummy(objects::RTD_14_IC17_TCS_BOARD, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
        objects::RTD_15_IC18_IMTQ,
        new Max31865Dummy(objects::RTD_15_IC18_IMTQ, objects::DUMMY_COM_IF, comCookieDummy));

-    std::map<object_id_t, Tmp1075Dummy*> tempTmpSensorDummies;
-    tempTmpSensorDummies.emplace(
+    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));
-    tempTmpSensorDummies.emplace(
+    tmpSensorDummies.emplace(
        objects::TMP1075_HANDLER_TCS_1,
        new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_1, objects::DUMMY_COM_IF, comCookieDummy));
-    tempTmpSensorDummies.emplace(
+    tmpSensorDummies.emplace(
        objects::TMP1075_HANDLER_PLPCDU_0,
        new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_0, objects::DUMMY_COM_IF, comCookieDummy));
-    tempTmpSensorDummies.emplace(
+    tmpSensorDummies.emplace(
        objects::TMP1075_HANDLER_PLPCDU_1,
        new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_1, objects::DUMMY_COM_IF, comCookieDummy));
-    tempTmpSensorDummies.emplace(
+    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, tempSensorDummies,
-                                  tempTmpSensorDummies);
+    new TemperatureSensorInserter(objects::THERMAL_TEMP_INSERTER, rtdSensorDummies,
+                                  tmpSensorDummies);
+    TcsBoardAssembly* tcsBoardAssy = ObjectFactory::createTcsBoardAssy(pwrSwitcher);
+    for (auto& rtd : rtdSensorDummies) {
+      rtd.second->connectModeTreeParent(*tcsBoardAssy);
+    }
+    for (auto& tmp : tmpSensorDummies) {
+      tmp.second->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
+    }
+  }
+  auto* camSwitcher = new CamSwitcher(objects::CAM_SWITCHER, pwrSwitcher, power::NO_SWITCH);
+  camSwitcher->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+  auto* scexDummy = new ScexDummy(objects::SCEX, objects::DUMMY_COM_IF, comCookieDummy);
+  scexDummy->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+  auto* plPcduDummy =
+      new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  plPcduDummy->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+  if (cfg.addPlocDummies) {
+    auto* plocMpsocDummy =
+        new PlocMpsocDummy(objects::PLOC_MPSOC_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    plocMpsocDummy->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+    auto* plocSupervisorDummy = new PlocSupervisorDummy(objects::PLOC_SUPERVISOR_HANDLER,
+                                                        objects::DUMMY_COM_IF, comCookieDummy);
+    plocSupervisorDummy->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
  }
-  new CamSwitcher(objects::CAM_SWITCHER, pwrSwitch, power::NO_SWITCH);
-  new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
 }
--- a/dummies/helpers.h
+++ b/dummies/helpers.h
@ -2,6 +2,8 @@

 #include <fsfw/power/PowerSwitchIF.h>

+class GpioIF;
+
 namespace dummy {

 struct DummyCfg {
@ -12,8 +14,9 @@ struct DummyCfg {
  bool addSusDummies = true;
  bool addTempSensorDummies = true;
  bool addRtdComIFDummy = true;
+  bool addPlocDummies = true;
 };

-void createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch);
+void createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch, GpioIF* gpioIF);

 }  // namespace dummy
--- a/2
+++ b/2
--- a/linux/ObjectFactory.cpp
+++ b/linux/ObjectFactory.cpp
@ -11,6 +11,7 @@
 #include <linux/callbacks/gpioCallbacks.h>
 #include <linux/devices/Max31865RtdLowlevelHandler.h>
 #include <mission/controller/AcsController.h>
+#include <mission/core/GenericFactory.h>
 #include <mission/devices/Max31865EiveHandler.h>
 #include <mission/devices/ScexDeviceHandler.h>
 #include <mission/devices/SusHandler.h>
@ -29,7 +30,7 @@
 #include "mission/system/tree/tcsModeTree.h"

 void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF,
-                                              PowerSwitchIF* pwrSwitcher, std::string spiDev,
+                                              PowerSwitchIF& pwrSwitcher, std::string spiDev,
                                              bool swap0And6) {
  using namespace gpio;
  GpioCookie* gpioCookieSus = new GpioCookie();
@ -173,22 +174,8 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  fdir = new SusFdir(objects::SUS_11_R_LOC_XBYMZB_PT_ZB);
  susHandlers[11]->setCustomFdir(fdir);

-  std::array<object_id_t, 12> susIds = {
-      objects::SUS_0_N_LOC_XFYFZM_PT_XF,  objects::SUS_1_N_LOC_XBYFZM_PT_XB,
-      objects::SUS_2_N_LOC_XFYBZB_PT_YB,  objects::SUS_3_N_LOC_XFYBZF_PT_YF,
-      objects::SUS_4_N_LOC_XMYFZF_PT_ZF,  objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
-      objects::SUS_6_R_LOC_XFYBZM_PT_XF,  objects::SUS_7_R_LOC_XBYBZM_PT_XB,
-      objects::SUS_8_R_LOC_XBYBZB_PT_YB,  objects::SUS_9_R_LOC_XBYBZB_PT_YF,
-      objects::SUS_10_N_LOC_XMYBZF_PT_ZF, objects::SUS_11_R_LOC_XBYMZB_PT_ZB};
-  SusAssHelper susAssHelper = SusAssHelper(susIds);
-  auto susAss = new SusAssembly(objects::SUS_BOARD_ASS, pwrSwitcher, susAssHelper);
  for (auto& sus : susHandlers) {
    if (sus != nullptr) {
-      ReturnValue_t result = sus->connectModeTreeParent(*susAss);
-      if (result != returnvalue::OK) {
-        sif::error << "Connecting SUS " << sus->getObjectId() << " to SUS assembly failed"
-                   << std::endl;
-      }
 #if OBSW_TEST_SUS == 1
      sus->setStartUpImmediately();
      sus->setToGoToNormalMode(true);
@ -198,7 +185,11 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
 #endif
    }
  }
-  susAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
+  std::array<DeviceHandlerBase*, 12> susDhbs;
+  for (unsigned i = 0; i < susDhbs.size(); i++) {
+    susDhbs[i] = susHandlers[i];
+  }
+  createSusAssy(pwrSwitcher, susDhbs);
 #endif /* OBSW_ADD_SUN_SENSORS == 1 */
 }

@ -279,32 +270,13 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
      {addresses::RTD_IC_18, gpioIds::RTD_IC_18},
  }};
  // HSPD: Heatspreader
-  std::array<std::pair<object_id_t, std::string>, NUM_RTDS> rtdInfos = {{
-      {objects::RTD_0_IC3_PLOC_HEATSPREADER, "RTD_0_PLOC_HSPD"},
-      {objects::RTD_1_IC4_PLOC_MISSIONBOARD, "RTD_1_PLOC_MISSIONBRD"},
-      {objects::RTD_2_IC5_4K_CAMERA, "RTD_2_4K_CAMERA"},
-      {objects::RTD_3_IC6_DAC_HEATSPREADER, "RTD_3_DAC_HSPD"},
-      {objects::RTD_4_IC7_STARTRACKER, "RTD_4_STARTRACKER"},
-      {objects::RTD_5_IC8_RW1_MX_MY, "RTD_5_RW1_MX_MY"},
-      {objects::RTD_6_IC9_DRO, "RTD_6_DRO"},
-      {objects::RTD_7_IC10_SCEX, "RTD_7_SCEX"},
-      {objects::RTD_8_IC11_X8, "RTD_8_X8"},
-      {objects::RTD_9_IC12_HPA, "RTD_9_HPA"},
-      {objects::RTD_10_IC13_PL_TX, "RTD_10_PL_TX,"},
-      {objects::RTD_11_IC14_MPA, "RTD_11_MPA"},
-      {objects::RTD_12_IC15_ACU, "RTD_12_ACU"},
-      {objects::RTD_13_IC16_PLPCDU_HEATSPREADER, "RTD_13_PLPCDU_HSPD"},
-      {objects::RTD_14_IC17_TCS_BOARD, "RTD_14_TCS_BOARD"},
-      {objects::RTD_15_IC18_IMTQ, "RTD_15_IMTQ"},
-  }};
+
  std::array<SpiCookie*, NUM_RTDS> rtdCookies = {};
  std::array<Max31865EiveHandler*, NUM_RTDS> rtds = {};
  RtdFdir* rtdFdir = nullptr;

-  TcsBoardHelper helper(rtdInfos);
-  TcsBoardAssembly* tcsBoardAss = new TcsBoardAssembly(
-      objects::TCS_BOARD_ASS, pwrSwitcher, pcdu::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
-  tcsBoardAss->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
+  TcsBoardAssembly* tcsBoardAss = ObjectFactory::createTcsBoardAssy(*pwrSwitcher);
+
  // Create special low level reader communication interface
  new Max31865RtdReader(objects::SPI_RTD_COM_IF, comIF, gpioComIF);
  for (uint8_t idx = 0; idx < NUM_RTDS; idx++) {
@ -312,16 +284,16 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
                                    MAX31865::MAX_REPLY_SIZE, spi::RTD_MODE, spi::RTD_SPEED);
    rtdCookies[idx]->setMutexParams(MutexIF::TimeoutType::WAITING, spi::RTD_CS_TIMEOUT);
    Max31865ReaderCookie* rtdLowLevelCookie =
-        new Max31865ReaderCookie(rtdInfos[idx].first, idx, rtdInfos[idx].second, rtdCookies[idx]);
+        new Max31865ReaderCookie(RTD_INFOS[idx].first, idx, RTD_INFOS[idx].second, rtdCookies[idx]);
    rtds[idx] =
-        new Max31865EiveHandler(rtdInfos[idx].first, objects::SPI_RTD_COM_IF, rtdLowLevelCookie);
-    rtds[idx]->setDeviceInfo(idx, rtdInfos[idx].second);
+        new Max31865EiveHandler(RTD_INFOS[idx].first, objects::SPI_RTD_COM_IF, rtdLowLevelCookie);
+    rtds[idx]->setDeviceInfo(idx, RTD_INFOS[idx].second);
    ReturnValue_t result = rtds[idx]->connectModeTreeParent(*tcsBoardAss);
    if (result != returnvalue::OK) {
      sif::error << "Connecting RTD " << static_cast<int>(idx) << " to RTD Assembly failed"
                 << std::endl;
    }
-    rtdFdir = new RtdFdir(rtdInfos[idx].first);
+    rtdFdir = new RtdFdir(RTD_INFOS[idx].first);
    rtds[idx]->setCustomFdir(rtdFdir);
 #if OBSW_DEBUG_RTD == 1
    rtds[idx]->setDebugMode(true, 5);
--- a/linux/ObjectFactory.h
+++ b/linux/ObjectFactory.h
@ -20,7 +20,7 @@ class AcsController;

 namespace ObjectFactory {

-void createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF, PowerSwitchIF* pwrSwitcher,
+void createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF, PowerSwitchIF& pwrSwitcher,
                               std::string spiDev, bool swap0And6);
 void createRtdComponents(std::string spiDev, GpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher,
                         SpiComIF* comIF);
--- a/linux/boardtest/UartTestClass.h
+++ b/linux/boardtest/UartTestClass.h
@ -10,7 +10,7 @@

 #include <array>

-#include "lwgps/lwgps.h"
+//#include "lwgps/lwgps.h"
 #include "mission/devices/devicedefinitions/ScexDefinitions.h"
 #include "test/TestTask.h"

@ -59,7 +59,7 @@ class UartTestClass : public TestTask {
  DleEncoder dleEncoder = DleEncoder();
  SerialCookie* uartCookie = nullptr;
  size_t encodedLen = 0;
-  lwgps_t gpsData = {};
+  // lwgps_t gpsData = {};
  struct termios tty = {};
  int serialPort = 0;
  bool startFound = false;
--- a/linux/devices/GpsHyperionLinuxController.cpp
+++ b/linux/devices/GpsHyperionLinuxController.cpp
@ -102,6 +102,9 @@ ReturnValue_t GpsHyperionLinuxController::performOperation(uint8_t opCode) {
  handleQueue();
  poolManager.performHkOperation();
  while (true) {
+#if OBSW_THREAD_TRACING == 1
+    trace::threadTrace(opCounter, "GPS CTRL");
+#endif
    bool callAgainImmediately = readGpsDataFromGpsd();
    if (not callAgainImmediately) {
      handleQueue();
--- a/linux/devices/GpsHyperionLinuxController.h
+++ b/linux/devices/GpsHyperionLinuxController.h
@ -6,6 +6,7 @@
 #include "fsfw/controller/ExtendedControllerBase.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 #include "mission/devices/devicedefinitions/GPSDefinitions.h"
+#include "mission/trace.h"

 #ifdef FSFW_OSAL_LINUX
 #include <gps.h>
@ -60,6 +61,9 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
  Countdown maxTimeToReachFix = Countdown(MAX_SECONDS_TO_REACH_FIX * 1000);
  bool modeCommanded = false;
  bool timeInit = false;
+#if OBSW_THREAD_TRACING == 1
+  uint32_t opCounter = 0;
+#endif

  struct OneShotSwitches {
    void reset() {
--- a/linux/devices/Max31865RtdLowlevelHandler.cpp
+++ b/linux/devices/Max31865RtdLowlevelHandler.cpp
@ -70,8 +70,8 @@ bool Max31865RtdReader::periodicInitHandling() {
      return false;
    }
    if ((rtd->on or rtd->db.active) and not rtd->db.configured and rtd->cd.hasTimedOut()) {
-      ManualCsLockWrapper mg(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
-      if (mg.lockResult != returnvalue::OK or mg.gpioResult != returnvalue::OK) {
+      ManualCsLockWrapper mg1(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
+      if (mg1.lockResult != returnvalue::OK or mg1.gpioResult != returnvalue::OK) {
        sif::error << "Max31865RtdReader::periodicInitHandling: Manual CS lock failed" << std::endl;
        continue;
      }
@ -153,8 +153,8 @@ ReturnValue_t Max31865RtdReader::periodicReadHandling() {
      return returnvalue::FAILED;
    }
    if (rtdIsActive(rtd->idx)) {
-      ManualCsLockWrapper mg(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
-      if (mg.lockResult != returnvalue::OK or mg.gpioResult != returnvalue::OK) {
+      ManualCsLockWrapper mg1(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
+      if (mg1.lockResult != returnvalue::OK or mg1.gpioResult != returnvalue::OK) {
        sif::error << "Max31865RtdReader::periodicInitHandling: Manual CS lock failed" << std::endl;
        continue;
      }
--- a/linux/devices/ploc/PlocMPSoCHelper.cpp
+++ b/linux/devices/ploc/PlocMPSoCHelper.cpp
@ -3,7 +3,6 @@
 #include <filesystem>
 #include <fstream>

-#include "OBSWConfig.h"
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/FilesystemHelper.h"
 #endif
@ -34,6 +33,9 @@ ReturnValue_t PlocMPSoCHelper::performOperation(uint8_t operationCode) {
  ReturnValue_t result = returnvalue::OK;
  semaphore.acquire();
  while (true) {
+#if OBSW_THREAD_TRACING == 1
+    trace::threadTrace(opCounter, "PLOC MPSOC Helper");
+#endif
    switch (internalState) {
      case InternalState::IDLE: {
        semaphore.acquire();
--- a/linux/devices/ploc/PlocMPSoCHelper.h
+++ b/linux/devices/ploc/PlocMPSoCHelper.h
@ -11,6 +11,7 @@
 #include "fsfw/tmtcservices/SourceSequenceCounter.h"
 #include "fsfw_hal/linux/serial/SerialComIF.h"
 #include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
+#include "mission/trace.h"
 #ifdef XIPHOS_Q7S
 #include "bsp_q7s/fs/SdCardManager.h"
 #endif
@ -116,6 +117,10 @@ class PlocMPSoCHelper : public SystemObject, public ExecutableObjectIF {

  struct FlashWrite flashWrite;

+#if OBSW_THREAD_TRACING == 1
+  uint32_t opCounter = 0;
+#endif
+
  enum class InternalState { IDLE, FLASH_WRITE, FLASH_READ };

  InternalState internalState = InternalState::IDLE;
--- a/linux/devices/ploc/PlocSupvUartMan.cpp
+++ b/linux/devices/ploc/PlocSupvUartMan.cpp
@ -101,6 +101,9 @@ ReturnValue_t PlocSupvUartManager::performOperation(uint8_t operationCode) {
    lock->unlockMutex();
    semaphore->acquire();
    putTaskToSleep = false;
+#if OBSW_THREAD_TRACING == 1
+    trace::threadTrace(opCounter, "PLOC SUPV Helper PST");
+#endif
    while (true) {
      if (putTaskToSleep) {
        performUartShutdown();
--- a/linux/devices/ploc/PlocSupvUartMan.h
+++ b/linux/devices/ploc/PlocSupvUartMan.h
@ -15,6 +15,7 @@
 #include "fsfw/tasks/ExecutableObjectIF.h"
 #include "fsfw_hal/linux/serial/SerialComIF.h"
 #include "linux/devices/devicedefinitions/PlocSupervisorDefinitions.h"
+#include "mission/trace.h"
 #include "tas/crc.h"

 #ifdef XIPHOS_Q7S
@ -211,6 +212,9 @@ class PlocSupvUartManager : public DeviceCommunicationIF,
  supv::TmBase tmReader;
  int serialPort = 0;
  struct termios tty = {};
+#if OBSW_THREAD_TRACING == 1
+  uint32_t opCounter = 0;
+#endif

  struct EventBufferRequest {
    std::string path = "";
--- a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp
+++ b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp
@ -5,6 +5,7 @@
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>

+#include "OBSWConfig.h"
 #include "eive/definitions.h"
 #include "mission/devices/devicedefinitions/Max31865Definitions.h"

@ -184,7 +185,7 @@ ReturnValue_t pst::pstTest(FixedTimeslotTaskIF *thisSequence) {
  return returnvalue::OK;
 }

-ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
+ReturnValue_t pst::pstTcsAndAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
  /* Length of a communication cycle */
  uint32_t length = thisSequence->getPeriodMs();
  bool enableAside = true;
@ -240,7 +241,6 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
      thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
                            DeviceHandlerIF::GET_READ);
    }
-
    if (enableBside) {
      // B side
      thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * config::acs::SCHED_BLOCK_1_PERIOD,
@ -293,7 +293,6 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
    }
  }
  // SUS: 16 ms
-
  bool addSus0 = true;
  bool addSus1 = true;
  bool addSus2 = true;
@ -441,7 +440,6 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
      thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
    }
-
    if (addSus6) {
      thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0,
                            DeviceHandlerIF::PERFORM_OPERATION);
@ -464,7 +462,6 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
      thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF,
                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
    }
-
    if (addSus7) {
      thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0,
                            DeviceHandlerIF::PERFORM_OPERATION);
@ -487,7 +484,6 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
      thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB,
                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
    }
-
    if (addSus8) {
      thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0,
                            DeviceHandlerIF::PERFORM_OPERATION);
@ -510,7 +506,6 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
      thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB,
                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
    }
-
    if (addSus9) {
      thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0,
                            DeviceHandlerIF::PERFORM_OPERATION);
@ -522,6 +517,7 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
                            DeviceHandlerIF::SEND_READ);
      thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0,
                            DeviceHandlerIF::GET_READ);
+
      thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF,
                            length * config::acs::SCHED_BLOCK_1_PERIOD,
                            DeviceHandlerIF::SEND_WRITE);
@ -532,7 +528,6 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
      thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF,
                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
    }
-
    if (addSus10) {
      thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0,
                            DeviceHandlerIF::PERFORM_OPERATION);
@ -555,7 +550,6 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
      thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF,
                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
    }
-
    if (addSus11) {
      thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0,
                            DeviceHandlerIF::PERFORM_OPERATION);
@ -639,6 +633,129 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
  }

  if (cfg.scheduleRws) {
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::SEND_WRITE);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::SEND_WRITE);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::SEND_WRITE);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::SEND_WRITE);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::GET_WRITE);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::GET_WRITE);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::GET_WRITE);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::GET_WRITE);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::SEND_READ);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::SEND_READ);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::SEND_READ);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::SEND_READ);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::GET_READ);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::GET_READ);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::GET_READ);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::GET_READ);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::SEND_WRITE);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::SEND_WRITE);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::SEND_WRITE);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::SEND_WRITE);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::GET_WRITE);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::GET_WRITE);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::GET_WRITE);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::GET_WRITE);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::SEND_READ);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::SEND_READ);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::SEND_READ);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::SEND_READ);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::GET_READ);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::GET_READ);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::GET_READ);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::GET_READ);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::SEND_WRITE);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::SEND_WRITE);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::SEND_WRITE);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::SEND_WRITE);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::GET_WRITE);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::GET_WRITE);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::GET_WRITE);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::GET_WRITE);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::SEND_READ);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::SEND_READ);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::SEND_READ);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::SEND_READ);
+    //
+    //    thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::GET_READ);
+    //    thisSequence->addSlot(objects::RW2, length * 0, DeviceHandlerIF::GET_READ);
+    //    thisSequence->addSlot(objects::RW3, length * 0, DeviceHandlerIF::GET_READ);
+    //    thisSequence->addSlot(objects::RW4, length * 0, DeviceHandlerIF::GET_READ);
+  }
+
+  if (cfg.scheduleRws) {
+    // this is the torquing cycle
+    thisSequence->addSlot(objects::RW1, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::RW2, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::RW3, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::RW4, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+
+    thisSequence->addSlot(objects::RW1, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::RW2, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::RW3, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::RW4, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_WRITE);
+
+    thisSequence->addSlot(objects::RW1, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::RW2, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::RW3, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::RW4, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_WRITE);
+
+    thisSequence->addSlot(objects::RW1, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::RW2, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::RW3, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::RW4, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::SEND_READ);
+
+    thisSequence->addSlot(objects::RW1, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::RW2, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::RW3, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::RW4, length * config::acs::SCHED_BLOCK_2_PERIOD,
+                          DeviceHandlerIF::GET_READ);
+
    thisSequence->addSlot(objects::RW1, length * config::acs::SCHED_BLOCK_2_PERIOD,
                          DeviceHandlerIF::PERFORM_OPERATION);
    thisSequence->addSlot(objects::RW2, length * config::acs::SCHED_BLOCK_2_PERIOD,
@ -684,5 +801,8 @@ ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg) {
    thisSequence->addSlot(objects::RW4, length * config::acs::SCHED_BLOCK_2_PERIOD,
                          DeviceHandlerIF::GET_READ);
  }
+
+  thisSequence->addSlot(objects::SPI_RTD_COM_IF, length * 0.5, 0);
+
  return returnvalue::OK;
 }
--- a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.h
+++ b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.h
@ -49,7 +49,7 @@ ReturnValue_t pstGompaceCan(FixedTimeslotTaskIF* thisSequence);

 ReturnValue_t pstSpiAndSyrlinks(FixedTimeslotTaskIF* thisSequence);

-ReturnValue_t pstAcs(FixedTimeslotTaskIF* thisSequence, AcsPstCfg cfg);
+ReturnValue_t pstTcsAndAcs(FixedTimeslotTaskIF* thisSequence, AcsPstCfg cfg);

 ReturnValue_t pstI2c(FixedTimeslotTaskIF* thisSequence);

--- a/linux/ipcore/PdecConfig.cpp
+++ b/linux/ipcore/PdecConfig.cpp
@ -22,7 +22,7 @@ void PdecConfig::initialize() {
  word |= POSITIVE_WINDOW;
  configWords[0] = word;
  word = 0;
-  word |= (NEGATIVE_WINDOW << 24);
+  word |= (static_cast<uint32_t>(NEGATIVE_WINDOW) << 24);
  word |= (HIGH_AU_MAP_ID << 16);
  word |= (ENABLE_DERANDOMIZER << 8);
  configWords[1] = word;
--- a/linux/ipcore/PdecHandler.cpp
+++ b/linux/ipcore/PdecHandler.cpp
@ -99,6 +99,7 @@ ReturnValue_t PdecHandler::performOperation(uint8_t operationCode) {
  } else if (OP_MODE == Modes::IRQ) {
    return irqOperation();
  }
+  return returnvalue::FAILED;
 }

 ReturnValue_t PdecHandler::polledOperation() {
--- a/linux/ipcore/pdec.h
+++ b/linux/ipcore/pdec.h
@ -15,7 +15,7 @@ static constexpr uint32_t NEW_FAR_MASK = 1 << 2;
 static constexpr uint32_t TC_ABORT_MASK = 1 << 1;
 static constexpr uint32_t TC_NEW_MASK = 1 << 0;

-static constexpr uint32_t FAR_STAT_MASK = 1 << 31;
+static constexpr uint32_t FAR_STAT_MASK = 1UL << 31;

 static const uint32_t FRAME_ANA_MASK = 0x70000000;
 static const uint32_t IREASON_MASK = 0x0E000000;
--- a/linux/scheduling.cpp
+++ b/linux/scheduling.cpp
@ -8,8 +8,7 @@
 #include "ObjectFactory.h"
 #include "eive/objects.h"

-void scheduling::schedulingScex(TaskFactory& factory, PeriodicTaskIF*& scexDevHandler,
-                                PeriodicTaskIF*& scexReaderTask) {
+void scheduling::scheduleScexReader(TaskFactory& factory, PeriodicTaskIF*& scexReaderTask) {
  using namespace scheduling;
  ReturnValue_t result = returnvalue::OK;
 #if OBSW_PRINT_MISSED_DEADLINES == 1
@ -17,37 +16,6 @@ void scheduling::schedulingScex(TaskFactory& factory, PeriodicTaskIF*& scexDevHa
 #else
  void (*missedDeadlineFunc)(void) = nullptr;
 #endif
-  scexDevHandler = factory.createPeriodicTask(
-      "SCEX_DEV", 35, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.5, missedDeadlineFunc);
-
-  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::PERFORM_OPERATION);
-  if (result != returnvalue::OK) {
-    printAddObjectError("SCEX_DEV", objects::SCEX);
-  }
-  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_WRITE);
-  if (result != returnvalue::OK) {
-    printAddObjectError("SCEX_DEV", objects::SCEX);
-  }
-  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_WRITE);
-  if (result != returnvalue::OK) {
-    printAddObjectError("SCEX_DEV", objects::SCEX);
-  }
-  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_READ);
-  if (result != returnvalue::OK) {
-    printAddObjectError("SCEX_DEV", objects::SCEX);
-  }
-  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_READ);
-  if (result != returnvalue::OK) {
-    printAddObjectError("SCEX_DEV", objects::SCEX);
-  }
-  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_READ);
-  if (result != returnvalue::OK) {
-    printAddObjectError("SCEX_DEV", objects::SCEX);
-  }
-  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_READ);
-  if (result != returnvalue::OK) {
-    printAddObjectError("SCEX_DEV", objects::SCEX);
-  }

  result = returnvalue::OK;
  scexReaderTask = factory.createPeriodicTask(
@ -79,3 +47,35 @@ void scheduling::addMpsocSupvHandlers(PeriodicTaskIF* plTask) {
  plTask->addComponent(objects::PLOC_MPSOC_HANDLER, DeviceHandlerIF::GET_READ);
 #endif
 }
+
+void scheduling::scheduleScexDev(PeriodicTaskIF*& scexDevHandler) {
+  ReturnValue_t result =
+      scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::PERFORM_OPERATION);
+  if (result != returnvalue::OK) {
+    printAddObjectError("SCEX_DEV", objects::SCEX);
+  }
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_WRITE);
+  if (result != returnvalue::OK) {
+    printAddObjectError("SCEX_DEV", objects::SCEX);
+  }
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_WRITE);
+  if (result != returnvalue::OK) {
+    printAddObjectError("SCEX_DEV", objects::SCEX);
+  }
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_READ);
+  if (result != returnvalue::OK) {
+    printAddObjectError("SCEX_DEV", objects::SCEX);
+  }
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_READ);
+  if (result != returnvalue::OK) {
+    printAddObjectError("SCEX_DEV", objects::SCEX);
+  }
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::SEND_READ);
+  if (result != returnvalue::OK) {
+    printAddObjectError("SCEX_DEV", objects::SCEX);
+  }
+  result = scexDevHandler->addComponent(objects::SCEX, DeviceHandlerIF::GET_READ);
+  if (result != returnvalue::OK) {
+    printAddObjectError("SCEX_DEV", objects::SCEX);
+  }
+}
--- a/linux/scheduling.h
+++ b/linux/scheduling.h
@ -3,7 +3,7 @@
 #include <fsfw/tasks/TaskFactory.h>

 namespace scheduling {
-void schedulingScex(TaskFactory& factory, PeriodicTaskIF*& scexDevHandler,
-                    PeriodicTaskIF*& scexReaderTask);
+void scheduleScexDev(PeriodicTaskIF*& scexDevHandler);
+void scheduleScexReader(TaskFactory& factory, PeriodicTaskIF*& scexReaderTask);
 void addMpsocSupvHandlers(PeriodicTaskIF* task);
 }  // namespace scheduling
--- a/misc/eclipse/.cproject
+++ b/misc/eclipse/.cproject
@ -57,7 +57,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<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=""/>
+						<entry excluding="thirdparty/json/tests|thirdparty/json/docs|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-release-q7s|bsp_linux_board|thirdparty/json/single_include|cmake-build-debug-q7s-em|cmake-build-debug-q7s/_deps/etl-src/temp|thirdparty/rapidcsv/examples|cmake-build-debug-q7s/_deps/etl-src/images|fsfwconfig|cmake-build-debug-q7s/_deps/etl-src/subprojects|thirdparty/json/third_party|bsp_q7s|thirdparty/json/test|bsp_te0720_1cfa|scripts|cmake-build-debug-q7s/_deps/etl-src/cmake|bsp_egse|build-Debug-RPi|thirdparty/rapidcsv/doc|thirdparty/json/doc|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-release-q7s-em|cmake-build-debug-q7s|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug/_deps|thirdparty/rapidcsv/tests|archive|thirdparty/json/cmake|thirdparty/json/benchmarks" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -119,7 +119,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<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=""/>
+						<entry excluding="thirdparty/json/tests|thirdparty/json/docs|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-release-q7s|bsp_linux_board|thirdparty/json/single_include|cmake-build-debug-q7s-em|cmake-build-debug-q7s/_deps/etl-src/temp|thirdparty/rapidcsv/examples|cmake-build-debug-q7s/_deps/etl-src/images|fsfwconfig|cmake-build-debug-q7s/_deps/etl-src/subprojects|thirdparty/json/third_party|bsp_q7s|thirdparty/json/test|bsp_te0720_1cfa|scripts|cmake-build-debug-q7s/_deps/etl-src/cmake|bsp_egse|build-Debug-RPi|thirdparty/rapidcsv/doc|thirdparty/json/doc|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-release-q7s-em|cmake-build-debug-q7s|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug/_deps|thirdparty/rapidcsv/tests|archive|thirdparty/json/cmake|thirdparty/json/benchmarks" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -187,7 +187,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<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=""/>
+						<entry excluding="thirdparty/json/tests|thirdparty/json/docs|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-release-q7s|bsp_linux_board|thirdparty/json/single_include|cmake-build-debug-q7s-em|cmake-build-debug-q7s/_deps/etl-src/temp|thirdparty/rapidcsv/examples|cmake-build-debug-q7s/_deps/etl-src/images|fsfwconfig|cmake-build-debug-q7s/_deps/etl-src/subprojects|thirdparty/json/third_party|bsp_q7s|thirdparty/json/test|bsp_te0720_1cfa|scripts|cmake-build-debug-q7s/_deps/etl-src/cmake|bsp_egse|build-Debug-RPi|thirdparty/rapidcsv/doc|thirdparty/json/doc|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-release-q7s-em|cmake-build-debug-q7s|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug/_deps|thirdparty/rapidcsv/tests|archive|thirdparty/json/cmake|thirdparty/json/benchmarks" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -255,7 +255,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<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=""/>
+						<entry excluding="thirdparty/json/tests|thirdparty/json/docs|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-release-q7s|bsp_linux_board|thirdparty/json/single_include|cmake-build-debug-q7s-em|cmake-build-debug-q7s/_deps/etl-src/temp|thirdparty/rapidcsv/examples|cmake-build-debug-q7s/_deps/etl-src/images|fsfwconfig|cmake-build-debug-q7s/_deps/etl-src/subprojects|thirdparty/json/third_party|bsp_q7s|thirdparty/json/test|bsp_te0720_1cfa|scripts|cmake-build-debug-q7s/_deps/etl-src/cmake|bsp_egse|build-Debug-RPi|thirdparty/rapidcsv/doc|thirdparty/json/doc|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-release-q7s-em|cmake-build-debug-q7s|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|cmake-build-debug-q7s/_deps/etl-src/support|cmake-build-debug/_deps|thirdparty/rapidcsv/tests|archive|thirdparty/json/cmake|thirdparty/json/benchmarks" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -418,7 +418,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<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=""/>
+						<entry excluding="thirdparty/json/tests|thirdparty/json/docs|build-Debug-RPi/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-release-q7s|build-Debug-RPi/_deps/etl-src/temp|thirdparty/json/single_include|cmake-build-debug-q7s-em|cmake-build-debug-q7s/_deps/etl-src/temp|thirdparty/rapidcsv/examples|build-Debug-RPi/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/images|build-Debug-RPi/_deps/etl-src/subprojects|cmake-build-debug|cmake-build-debug-q7s/_deps/etl-src/subprojects|thirdparty/json/third_party|bsp_hosted|thirdparty/json/test|bsp_te0720_1cfa|scripts|build-Debug-RPi/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/cmake|bsp_egse|thirdparty/rapidcsv/doc|build-Debug-RPi/_deps/etl-src/examples|thirdparty/json/doc|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-release-q7s-em|build-Debug-RPi/_deps/etl-src/test|build-Debug-RPi/_deps/etl-src/scripts|cmake-build-debug-q7s|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/test|build-Debug-RPi/_deps/etl-src/arduino|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|build-Debug-RPi/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/support|thirdparty/rapidcsv/tests|archive|thirdparty/json/cmake|thirdparty/json/benchmarks" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -580,7 +580,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<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=""/>
+						<entry excluding="thirdparty/json/tests|thirdparty/json/docs|build-Debug-RPi/_deps/etl-src/uml|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-release-q7s|build-Debug-RPi/_deps/etl-src/temp|thirdparty/json/single_include|cmake-build-debug-q7s-em|cmake-build-debug-q7s/_deps/etl-src/temp|thirdparty/rapidcsv/examples|build-Debug-RPi/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/images|build-Debug-RPi/_deps/etl-src/subprojects|cmake-build-debug|cmake-build-debug-q7s/_deps/etl-src/subprojects|thirdparty/json/third_party|bsp_hosted|thirdparty/json/test|bsp_te0720_1cfa|scripts|build-Debug-RPi/_deps/etl-src/cmake|cmake-build-debug-q7s/_deps/etl-src/cmake|bsp_egse|thirdparty/rapidcsv/doc|build-Debug-RPi/_deps/etl-src/examples|thirdparty/json/doc|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-release-q7s-em|build-Debug-RPi/_deps/etl-src/test|build-Debug-RPi/_deps/etl-src/scripts|cmake-build-debug-q7s|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/test|build-Debug-RPi/_deps/etl-src/arduino|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|build-Debug-RPi/_deps/etl-src/support|cmake-build-debug-q7s/_deps/etl-src/support|thirdparty/rapidcsv/tests|archive|thirdparty/json/cmake|thirdparty/json/benchmarks" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -750,7 +750,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<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|cmake-build-debug-q7s-em|build-Debug-Host|build-Watchdog-Debug" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="thirdparty/json/tests|thirdparty/json/docs|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-release-q7s|bsp_linux_board|thirdparty/json/single_include|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s-em|thirdparty/rapidcsv/examples|build-Debug-Host|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug|cmake-build-debug-q7s/_deps/etl-src/subprojects|thirdparty/json/third_party|bsp_hosted|thirdparty/json/test|bsp_te0720_1cfa|scripts|cmake-build-debug-q7s/_deps/etl-src/cmake|bsp_egse|build-Debug-RPi|thirdparty/rapidcsv/doc|thirdparty/json/doc|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-release-q7s-em|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|cmake-build-debug-q7s/_deps/etl-src/support|thirdparty/rapidcsv/tests|archive|build-Watchdog-Debug|thirdparty/json/cmake|thirdparty/json/benchmarks" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -917,7 +917,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<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=""/>
+						<entry excluding="thirdparty/json/tests|thirdparty/json/docs|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-release-q7s/_deps/etl-src/support|bsp_linux_board|thirdparty/json/single_include|cmake-build-debug-q7s/_deps/etl-src/temp|cmake-build-debug-q7s-em|thirdparty/rapidcsv/examples|build-Debug-Host|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug|cmake-build-debug-q7s/_deps/etl-src/subprojects|thirdparty/json/third_party|bsp_hosted|thirdparty/json/test|bsp_te0720_1cfa|scripts|cmake-build-release-q7s/_deps/etl-src/test|cmake-build-release-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/cmake|bsp_egse|cmake-build-release-q7s/_deps/etl-src/arduino|build-Debug-RPi|cmake-build-release-q7s/_deps/etl-src/cmake|thirdparty/rapidcsv/doc|thirdparty/json/doc|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-release-q7s-em|cmake-build-debug-q7s|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-release-q7s/_deps/etl-src/uml|cmake-build-release-q7s/_deps/etl-src/examples|cmake-build-debug-q7s/_deps/etl-src/arduino|cmake-build-release-q7s/_deps/etl-src/temp|tmtc|cmake-build-release-q7s/_deps/etl-src/images|cmake-build-release-q7s/_deps/etl-src/subprojects|cmake-build-debug-q7s/_deps/etl-src/support|thirdparty/rapidcsv/tests|archive|build-Watchdog-Debug|thirdparty/json/cmake|thirdparty/json/benchmarks" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -1084,7 +1084,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<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" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
+						<entry excluding="thirdparty/json/tests|thirdparty/json/docs|cmake-build-debug-q7s-em/_deps/etl-src/test|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-release-q7s|bsp_linux_board|thirdparty/json/single_include|cmake-build-debug-q7s/_deps/etl-src/temp|thirdparty/rapidcsv/examples|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug-q7s/_deps/etl-src/subprojects|thirdparty/json/third_party|bsp_hosted|thirdparty/json/test|bsp_te0720_1cfa|scripts|cmake-build-debug-q7s/_deps/etl-src/cmake|bsp_egse|build-Debug-RPi|thirdparty/rapidcsv/doc|thirdparty/json/doc|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-release-q7s-em|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|cmake-build-debug-q7s/_deps/etl-src/support|thirdparty/rapidcsv/tests|archive|thirdparty/json/cmake|thirdparty/json/benchmarks" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -1149,7 +1149,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="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 excluding="thirdparty/json/tests|thirdparty/json/docs|cmake-build-debug-q7s-em/_deps/etl-src/test|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-release-q7s|bsp_linux_board|thirdparty/json/single_include|cmake-build-debug-q7s/_deps/etl-src/temp|thirdparty/rapidcsv/examples|cmake-build-debug-q7s/_deps/etl-src/images|fsfwconfig|cmake-build-debug-q7s/_deps/etl-src/subprojects|thirdparty/json/third_party|thirdparty/json/test|bsp_te0720_1cfa|scripts|cmake-build-debug-q7s/_deps/etl-src/cmake|bsp_egse|build-Debug-RPi|thirdparty/rapidcsv/doc|thirdparty/json/doc|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-release-q7s-em|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|cmake-build-debug-q7s/_deps/etl-src/support|thirdparty/rapidcsv/tests|archive|thirdparty/json/cmake|thirdparty/json/benchmarks" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -1317,7 +1317,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<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=""/>
+						<entry excluding="thirdparty/json/tests|thirdparty/json/docs|cmake-build-debug-q7s-em/_deps/etl-src/test|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-release-q7s|bsp_linux_board|thirdparty/json/single_include|cmake-build-debug-q7s/_deps/etl-src/temp|thirdparty/rapidcsv/examples|build-Debug-Host|cmake-build-debug-q7s/_deps/etl-src/images|cmake-build-debug|cmake-build-debug-q7s/_deps/etl-src/subprojects|thirdparty/json/third_party|bsp_hosted|thirdparty/json/test|bsp_te0720_1cfa|scripts|cmake-build-debug-q7s/_deps/etl-src/cmake|bsp_egse|build-Debug-RPi|thirdparty/rapidcsv/doc|thirdparty/json/doc|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-release-q7s-em|cmake-build-debug-q7s|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|cmake-build-debug-q7s/_deps/etl-src/support|thirdparty/rapidcsv/tests|archive|build-Watchdog-Debug|thirdparty/json/cmake|thirdparty/json/benchmarks" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -1386,7 +1386,7 @@
 						</toolChain>
 					</folderInfo>
 					<sourceEntries>
-						<entry excluding="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 excluding="thirdparty/json/tests|thirdparty/json/docs|cmake-build-debug-q7s-em/_deps/etl-src/test|cmake-build-debug-q7s/_deps/etl-src/uml|cmake-build-release-q7s|bsp_linux_board|thirdparty/json/single_include|cmake-build-debug-q7s/_deps/etl-src/temp|thirdparty/rapidcsv/examples|cmake-build-debug-q7s/_deps/etl-src/images|fsfwconfig|cmake-build-debug-q7s/_deps/etl-src/subprojects|thirdparty/json/third_party|thirdparty/json/test|bsp_te0720_1cfa|scripts|cmake-build-debug-q7s/_deps/etl-src/cmake|bsp_egse|build-Debug-RPi|thirdparty/rapidcsv/doc|thirdparty/json/doc|cmake-build-debug-q7s/_deps/etl-src/examples|cmake-build-release-q7s-em|cmake-build-debug-q7s/_deps/etl-src/scripts|cmake-build-debug-q7s/_deps/etl-src/test|cmake-build-debug-q7s/_deps/etl-src/arduino|tmtc|cmake-build-debug-q7s/_deps/etl-src/support|thirdparty/rapidcsv/tests|archive|thirdparty/json/cmake|thirdparty/json/benchmarks" flags="VALUE_WORKSPACE_PATH|RESOLVED" kind="sourcePath" name=""/>
 					</sourceEntries>
 				</configuration>
 			</storageModule>
@ -1451,18 +1451,9 @@
 		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.447898075;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.447898075.;cdt.managedbuild.tool.gnu.cpp.compiler.base.1522927967;cdt.managedbuild.tool.gnu.cpp.compiler.input.305765911">
 			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
 		</scannerConfigBuildInfo>
-		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.628631287;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.input.216437361">
-			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
-		</scannerConfigBuildInfo>
 		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.;cdt.managedbuild.tool.gnu.cpp.compiler.base.1405808772;cdt.managedbuild.tool.gnu.cpp.compiler.input.1960112549">
 			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
 		</scannerConfigBuildInfo>
-		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.;cdt.managedbuild.tool.gnu.c.compiler.base.1946711528;cdt.managedbuild.tool.gnu.c.compiler.input.584209663">
-			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
-		</scannerConfigBuildInfo>
-		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.190921171;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.190921171.;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.2044466190;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.input.1551006500">
-			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
-		</scannerConfigBuildInfo>
 		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.2065184927;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.input.920837857">
 			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
 		</scannerConfigBuildInfo>
@ -1478,6 +1469,48 @@
 		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1775596945;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1775596945.;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.1154394228;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.input.1228307894">
 			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
 		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.1043649249;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.1043649249.;cdt.managedbuild.tool.gnu.cpp.compiler.mingw.base.539225324;cdt.managedbuild.tool.gnu.cpp.compiler.input.1848997248">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.190921171;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.190921171.;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.193772074;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.input.2081570054">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.;cdt.managedbuild.tool.gnu.c.compiler.mingw.base.397223006;cdt.managedbuild.tool.gnu.c.compiler.input.1482659499">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1171630561;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1171630561.;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.308264050;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.input.259982159">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1031020513;cdt.managedbuild.toolchain.gnu.mingw.base.1031020513.519944638;cdt.managedbuild.tool.gnu.c.compiler.mingw.base.438317679;cdt.managedbuild.tool.gnu.c.compiler.input.336445831">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1939781894;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1939781894.;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.2002501811;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.input.1316209993">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.1898420988;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.input.2134154524">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.;cdt.managedbuild.tool.gnu.cpp.compiler.mingw.base.646655988;cdt.managedbuild.tool.gnu.cpp.compiler.input.1437856797">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1631077874;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1631077874.;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.1992099127;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.input.234631061">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.628631287;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.input.216437361">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.758550634;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.758550634.;cdt.managedbuild.tool.gnu.cpp.compiler.base.1957014384;cdt.managedbuild.tool.gnu.cpp.compiler.input.957560385">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1631077874;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1631077874.;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.715561087;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.input.1004720080">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.;cdt.managedbuild.tool.gnu.c.compiler.base.1946711528;cdt.managedbuild.tool.gnu.c.compiler.input.584209663">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.190921171;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.190921171.;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.2044466190;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.input.1551006500">
+			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
+		</scannerConfigBuildInfo>
 		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.1535302916;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.input.96000231">
 			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
 		</scannerConfigBuildInfo>
@ -1490,25 +1523,16 @@
 		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.364559455;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.364559455.;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.1970346305;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.input.2096585345">
 			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
 		</scannerConfigBuildInfo>
-		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.1043649249;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.1043649249.;cdt.managedbuild.tool.gnu.cpp.compiler.mingw.base.539225324;cdt.managedbuild.tool.gnu.cpp.compiler.input.1848997248">
-			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
-		</scannerConfigBuildInfo>
 		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.447898075;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.447898075.;cdt.managedbuild.tool.gnu.c.compiler.base.623389075;cdt.managedbuild.tool.gnu.c.compiler.input.1382191457">
 			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
 		</scannerConfigBuildInfo>
-		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.190921171;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.190921171.;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.193772074;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.input.2081570054">
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.758550634;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.758550634.;cdt.managedbuild.tool.gnu.c.compiler.base.1695077973;cdt.managedbuild.tool.gnu.c.compiler.input.509259725">
 			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
 		</scannerConfigBuildInfo>
-		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.;cdt.managedbuild.tool.gnu.c.compiler.mingw.base.397223006;cdt.managedbuild.tool.gnu.c.compiler.input.1482659499">
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1171630561;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1171630561.;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.1477130926;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.input.779990384">
 			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
 		</scannerConfigBuildInfo>
-		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1031020513;cdt.managedbuild.toolchain.gnu.mingw.base.1031020513.519944638;cdt.managedbuild.tool.gnu.c.compiler.mingw.base.438317679;cdt.managedbuild.tool.gnu.c.compiler.input.336445831">
-			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
-		</scannerConfigBuildInfo>
-		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1939781894;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.1939781894.;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.2002501811;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.input.1316209993">
-			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
-		</scannerConfigBuildInfo>
-		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.;cdt.managedbuild.tool.gnu.cpp.compiler.mingw.base.646655988;cdt.managedbuild.tool.gnu.cpp.compiler.input.1437856797">
+		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.1707795689.;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.978379831;ilg.gnuarmeclipse.managedbuild.cross.tool.c.compiler.input.780507143">
 			<autodiscovery enabled="true" problemReportingEnabled="true" selectedProfileId=""/>
 		</scannerConfigBuildInfo>
 		<scannerConfigBuildInfo instanceId="cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851;cdt.managedbuild.toolchain.gnu.mingw.base.1455833186.1840876443.2117915473.688890851.;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.1595165802;ilg.gnuarmeclipse.managedbuild.cross.tool.cpp.compiler.input.1925043110">
--- a/mission/CMakeLists.txt
+++ b/mission/CMakeLists.txt
@ -9,4 +9,4 @@ add_subdirectory(csp)
 add_subdirectory(cfdp)
 add_subdirectory(config)

-target_sources(${LIB_EIVE_MISSION} PRIVATE acsDefs.cpp)
+target_sources(${LIB_EIVE_MISSION} PRIVATE acsDefs.cpp trace.cpp)
--- a/mission/controller/AcsController.cpp
+++ b/mission/controller/AcsController.cpp
@ -50,6 +50,9 @@ ReturnValue_t AcsController::getParameter(uint8_t domainId, uint8_t parameterId,
 }

 void AcsController::performControlOperation() {
+#if OBSW_THREAD_TRACING == 1
+  trace::threadTrace(opCounter, "ACS & TCS PST");
+#endif
  switch (internalState) {
    case InternalState::STARTUP: {
      initialCountdown.resetTimer();
@ -116,10 +119,10 @@ void AcsController::performSafe() {
  navigation.useMekf(&sensorValues, &gyrDataProcessed, &mgmDataProcessed, &susDataProcessed,
                     &mekfData, &validMekf);

-  // Give desired satellite rate and sun direction to align
+  // give desired satellite rate and sun direction to align
  double satRateSafe[3] = {0, 0, 0}, sunTargetDir[3] = {0, 0, 0};
  guidance.getTargetParamsSafe(sunTargetDir, satRateSafe);
-  //	IF MEKF is working
+  // if MEKF is working
  double magMomMtq[3] = {0, 0, 0}, errAng = 0.0;
  bool magMomMtqValid = false;
  if (validMekf == returnvalue::OK) {
@ -137,8 +140,8 @@ void AcsController::performSafe() {
        sunTargetDir, satRateSafe, &errAng, magMomMtq, &magMomMtqValid);
  }

-  double dipolCmdUnits[3] = {0, 0, 0};
-  actuatorCmd.cmdDipolMtq(magMomMtq, dipolCmdUnits);
+  int16_t cmdDipolMtqs[3] = {0, 0, 0};
+  actuatorCmd.cmdDipolMtq(magMomMtq, cmdDipolMtqs);

  {
    PoolReadGuard pg(&ctrlValData);
@ -180,18 +183,15 @@ void AcsController::performSafe() {
      actuatorCmdData.rwTargetTorque.setValid(false);
      std::memcpy(actuatorCmdData.rwTargetSpeed.value, zeroVec, 4 * sizeof(int32_t));
      actuatorCmdData.rwTargetSpeed.setValid(false);
-      std::memcpy(actuatorCmdData.mtqTargetDipole.value, dipolCmdUnits, 3 * sizeof(int16_t));
+      std::memcpy(actuatorCmdData.mtqTargetDipole.value, cmdDipolMtqs, 3 * sizeof(int16_t));
      actuatorCmdData.mtqTargetDipole.setValid(true);
      actuatorCmdData.setValidity(true, false);
    }
  }
-  //  {
-  //    PoolReadGuard pg(&dipoleSet);
-  //    MutexGuard mg(torquer::lazyLock());
-  //    torquer::NEW_ACTUATION_FLAG = true;
-  //    dipoleSet.setDipoles(cmdDipolUnits[0], cmdDipolUnits[1], cmdDipolUnits[2],
-  //    torqueDuration);
-  //  }
+
+  //  commandActuators(cmdDipolMtqs[0], cmdDipolMtqs[1], cmdDipolMtqs[2],
+  //                   acsParameters.magnetorquesParameter.torqueDuration, 0, 0, 0, 0,
+  //                   acsParameters.rwHandlingParameters.rampTime);
 }

 void AcsController::performDetumble() {
@ -208,8 +208,8 @@ void AcsController::performDetumble() {
  detumble.bDotLaw(mgmDataProcessed.mgmVecTotDerivative.value,
                   mgmDataProcessed.mgmVecTotDerivative.isValid(), mgmDataProcessed.mgmVecTot.value,
                   mgmDataProcessed.mgmVecTot.isValid(), magMomMtq);
-  double dipolCmdUnits[3] = {0, 0, 0};
-  actuatorCmd.cmdDipolMtq(magMomMtq, dipolCmdUnits);
+  int16_t cmdDipolMtqs[3] = {0, 0, 0};
+  actuatorCmd.cmdDipolMtq(magMomMtq, cmdDipolMtqs);

  if (mekfData.satRotRateMekf.isValid() &&
      VectorOperations<double>::norm(mekfData.satRotRateMekf.value, 3) <
@ -228,10 +228,6 @@ void AcsController::performDetumble() {
    triggerEvent(acs::SAFE_RATE_RECOVERY);
  }

-  int16_t cmdDipolUnitsInt[3] = {0, 0, 0};
-  for (int i = 0; i < 3; ++i) {
-    cmdDipolUnitsInt[i] = std::round(dipolCmdUnits[i]);
-  }
  {
    PoolReadGuard pg(&actuatorCmdData);
    if (pg.getReadResult() == returnvalue::OK) {
@ -239,18 +235,15 @@ void AcsController::performDetumble() {
      actuatorCmdData.rwTargetTorque.setValid(false);
      std::memset(actuatorCmdData.rwTargetSpeed.value, 0, 4 * sizeof(int32_t));
      actuatorCmdData.rwTargetSpeed.setValid(false);
-      std::memcpy(actuatorCmdData.mtqTargetDipole.value, cmdDipolUnitsInt, 3 * sizeof(int16_t));
+      std::memcpy(actuatorCmdData.mtqTargetDipole.value, cmdDipolMtqs, 3 * sizeof(int16_t));
      actuatorCmdData.mtqTargetDipole.setValid(true);
      actuatorCmdData.setValidity(true, false);
    }
  }
-  //  {
-  //	  PoolReadGuard pg(&dipoleSet);
-  //	  MutexGuard mg(torquer::lazyLock());
-  //	  torquer::NEW_ACTUATION_FLAG = true;
-  //	  dipoleSet.setDipoles(cmdDipolUnitsInt[0], cmdDipolUnitsInt[1], cmdDipolUnitsInt[2],
-  // torqueDuration);
-  //  }
+
+  //  commandActuators(cmdDipolMtqs[0], cmdDipolMtqs[1], cmdDipolMtqs[2],
+  //                   acsParameters.magnetorquesParameter.torqueDuration, 0, 0, 0, 0,
+  //                   acsParameters.rwHandlingParameters.rampTime);
 }

 void AcsController::performPointingCtrl() {
@ -273,7 +266,7 @@ void AcsController::performPointingCtrl() {
  guidance.getDistributionMatrixRw(&sensorValues, *rwPseudoInv);
  double torquePtgRws[4] = {0, 0, 0, 0}, rwTrqNs[4] = {0, 0, 0, 0};
  double torqueRws[4] = {0, 0, 0, 0}, torqueRwsScaled[4] = {0, 0, 0, 0};
-  double mgtDpDes[3] = {0, 0, 0}, dipolUnits[3] = {0, 0, 0};  // Desaturation Dipol
+  double mgtDpDes[3] = {0, 0, 0};

  switch (submode) {
    case acs::PTG_IDLE:
@ -393,44 +386,62 @@ void AcsController::performPointingCtrl() {

  if (enableAntiStiction) {
    bool rwAvailable[4] = {true, true, true, true};  // WHICH INPUT SENSOR SET?
-    int32_t rwSpeed[4] = {
-        (sensorValues.rw1Set.currSpeed.value), (sensorValues.rw2Set.currSpeed.value),
-        (sensorValues.rw3Set.currSpeed.value), (sensorValues.rw4Set.currSpeed.value)};
+    int32_t rwSpeed[4] = {sensorValues.rw1Set.currSpeed.value, sensorValues.rw2Set.currSpeed.value,
+                          sensorValues.rw3Set.currSpeed.value, sensorValues.rw4Set.currSpeed.value};
    ptgCtrl.rwAntistiction(rwAvailable, rwSpeed, torqueRwsScaled);
  }

-  double cmdSpeedRws[4] = {0, 0, 0, 0};  // Should be given to the actuator reaction wheel as input
-  actuatorCmd.cmdSpeedToRws(&(sensorValues.rw1Set.currSpeed.value),
-                            &(sensorValues.rw2Set.currSpeed.value),
-                            &(sensorValues.rw3Set.currSpeed.value),
-                            &(sensorValues.rw4Set.currSpeed.value), torqueRwsScaled, cmdSpeedRws);
-  actuatorCmd.cmdDipolMtq(mgtDpDes, dipolUnits);
-
-  int16_t cmdDipolUnitsInt[3] = {0, 0, 0};
-  for (int i = 0; i < 3; ++i) {
-    cmdDipolUnitsInt[i] = std::round(dipolUnits[i]);
-  }
-  int32_t cmdRwSpeedInt[4] = {0, 0, 0, 0};
-  for (int i = 0; i < 4; ++i) {
-    cmdRwSpeedInt[i] = std::round(cmdSpeedRws[i]);
-  }
+  int32_t cmdSpeedRws[4] = {0, 0, 0, 0};
+  actuatorCmd.cmdSpeedToRws(sensorValues.rw1Set.currSpeed.value,
+                            sensorValues.rw2Set.currSpeed.value,
+                            sensorValues.rw3Set.currSpeed.value,
+                            sensorValues.rw4Set.currSpeed.value, torqueRwsScaled, cmdSpeedRws);
+  int16_t cmdDipolMtqs[3] = {0, 0, 0};
+  actuatorCmd.cmdDipolMtq(mgtDpDes, cmdDipolMtqs);

  {
    PoolReadGuard pg(&actuatorCmdData);
    if (pg.getReadResult() == returnvalue::OK) {
      std::memcpy(actuatorCmdData.rwTargetTorque.value, rwTrqNs, 4 * sizeof(double));
-      std::memcpy(actuatorCmdData.rwTargetSpeed.value, cmdRwSpeedInt, 4 * sizeof(int32_t));
-      std::memcpy(actuatorCmdData.mtqTargetDipole.value, cmdDipolUnitsInt, 3 * sizeof(int16_t));
+      std::memcpy(actuatorCmdData.rwTargetSpeed.value, cmdSpeedRws, 4 * sizeof(int32_t));
+      std::memcpy(actuatorCmdData.mtqTargetDipole.value, cmdDipolMtqs, 3 * sizeof(int16_t));
      actuatorCmdData.setValidity(true, true);
    }
  }
-  //  {
-  //	  PoolReadGuard pg(&dipoleSet);
-  //	  MutexGuard mg(torquer::lazyLock());
-  //	  torquer::NEW_ACTUATION_FLAG = true;
-  //	  dipoleSet.setDipoles(cmdDipolUnitsInt[0], cmdDipolUnitsInt[1], cmdDipolUnitsInt[2],
-  // torqueDuration);
-  //  }
+
+  //  commandActuators(cmdDipolMtqs[0], cmdDipolMtqs[1], cmdDipolMtqs[2],
+  //                   acsParameters.magnetorquesParameter.torqueDuration, cmdSpeedRws[0],
+  //                   cmdSpeedRws[1], cmdSpeedRws[2], cmdSpeedRws[3],
+  //                   acsParameters.rwHandlingParameters.rampTime);
+}
+
+ReturnValue_t AcsController::commandActuators(int16_t xDipole, int16_t yDipole, int16_t zDipole,
+                                              uint16_t dipoleTorqueDuration, int32_t rw1Speed,
+                                              int32_t rw2Speed, int32_t rw3Speed, int32_t rw4Speed,
+                                              uint16_t rampTime) {
+  {
+    PoolReadGuard pg(&dipoleSet);
+    MutexGuard mg(torquer::lazyLock());
+    torquer::NEW_ACTUATION_FLAG = true;
+    dipoleSet.setDipoles(xDipole, yDipole, zDipole, dipoleTorqueDuration);
+  }
+  {
+    PoolReadGuard pg(&rw1SpeedSet);
+    rw1SpeedSet.setRwSpeed(rw1Speed, rampTime);
+  }
+  {
+    PoolReadGuard pg(&rw2SpeedSet);
+    rw2SpeedSet.setRwSpeed(rw2Speed, rampTime);
+  }
+  {
+    PoolReadGuard pg(&rw3SpeedSet);
+    rw3SpeedSet.setRwSpeed(rw3Speed, rampTime);
+  }
+  {
+    PoolReadGuard pg(&rw4SpeedSet);
+    rw4SpeedSet.setRwSpeed(rw4Speed, rampTime);
+  }
+  return returnvalue::OK;
 }

 ReturnValue_t AcsController::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
--- a/mission/controller/AcsController.h
+++ b/mission/controller/AcsController.h
@ -17,8 +17,10 @@
 #include "eive/objects.h"
 #include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h"
 #include "fsfw_hal/devicehandlers/MgmRM3100Handler.h"
+#include "mission/devices/devicedefinitions/RwDefinitions.h"
 #include "mission/devices/devicedefinitions/SusDefinitions.h"
 #include "mission/devices/devicedefinitions/imtqHandlerDefinitions.h"
+#include "mission/trace.h"

 class AcsController : public ExtendedControllerBase, public ReceivesParameterMessagesIF {
 public:
@ -51,6 +53,10 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes

  ParameterHelper parameterHelper;

+#if OBSW_THREAD_TRACING == 1
+  uint32_t opCounter = 0;
+#endif
+
  enum class InternalState { STARTUP, INITIAL_DELAY, READY };

  InternalState internalState = InternalState::STARTUP;
@ -69,11 +75,20 @@ class AcsController : public ExtendedControllerBase, public ReceivesParameterMes
  void modeChanged(Mode_t mode, Submode_t submode);
  void announceMode(bool recursive);

+  ReturnValue_t commandActuators(int16_t xDipole, int16_t yDipole, int16_t zDipole,
+                                 uint16_t dipoleTorqueDuration, int32_t rw1Speed, int32_t rw2Speed,
+                                 int32_t rw3Speed, int32_t rw4Speed, uint16_t rampTime);
+
  /* ACS Sensor Values */
  ACS::SensorValues sensorValues;

-  /* ACS Datasets */
+  /* ACS Actuation Datasets */
  IMTQ::DipoleActuationSet dipoleSet = IMTQ::DipoleActuationSet(objects::IMTQ_HANDLER);
+  RwDefinitions::RwSpeedActuationSet rw1SpeedSet = RwDefinitions::RwSpeedActuationSet(objects::RW1);
+  RwDefinitions::RwSpeedActuationSet rw2SpeedSet = RwDefinitions::RwSpeedActuationSet(objects::RW2);
+  RwDefinitions::RwSpeedActuationSet rw3SpeedSet = RwDefinitions::RwSpeedActuationSet(objects::RW3);
+  RwDefinitions::RwSpeedActuationSet rw4SpeedSet = RwDefinitions::RwSpeedActuationSet(objects::RW4);
+  /* ACS Datasets */
  // MGMs
  acsctrl::MgmDataRaw mgmDataRaw;
  PoolEntry<float> mgm0VecRaw = PoolEntry<float>(3);
--- a/mission/controller/ThermalController.cpp
+++ b/mission/controller/ThermalController.cpp
@ -72,6 +72,9 @@ ReturnValue_t ThermalController::handleCommandMessage(CommandMessage* message) {
 }

 void ThermalController::performControlOperation() {
+#if OBSW_THREAD_TRACING == 1
+  trace::threadTrace(opCounter, "TCS Task");
+#endif
  switch (internalState) {
    case InternalState::STARTUP: {
      initialCountdown.resetTimer();
--- a/mission/controller/ThermalController.h
+++ b/mission/controller/ThermalController.h
@ -11,7 +11,8 @@

 #include <list>

-#include "../devices/HeaterHandler.h"
+#include "mission/devices/HeaterHandler.h"
+#include "mission/trace.h"

 /**
 * NOP Limit: Hard limit for device, usually from datasheet. Device damage is possible lif NOP limit
@ -152,6 +153,10 @@ class ThermalController : public ExtendedControllerBase {
  // Initial delay to make sure all pool variables have been initialized their owners
  Countdown initialCountdown = Countdown(DELAY);

+#if OBSW_THREAD_TRACING == 1
+  uint32_t opCounter = 0;
+#endif
+
  std::array<std::pair<bool, double>, 5> sensors;
  uint8_t numSensors = 0;

--- a/mission/controller/acs/AcsParameters.cpp
+++ b/mission/controller/acs/AcsParameters.cpp
@ -278,6 +278,9 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
        case 0x4:
          parameterWrapper->set(rwHandlingParameters.stictionTorque);
          break;
+        case 0x5:
+          parameterWrapper->set(rwHandlingParameters.rampTime);
+          break;
        default:
          return INVALID_IDENTIFIER_ID;
      }
@ -584,6 +587,9 @@ ReturnValue_t AcsParameters::getParameter(uint8_t domainId, uint8_t parameterId,
        case 0x5:
          parameterWrapper->set(magnetorquesParameter.DipolMax);
          break;
+        case 0x6:
+          parameterWrapper->set(magnetorquesParameter.torqueDuration);
+          break;
        default:
          return INVALID_IDENTIFIER_ID;
      }
--- a/mission/controller/acs/AcsParameters.h
+++ b/mission/controller/acs/AcsParameters.h
@ -792,6 +792,8 @@ class AcsParameters : public HasParametersIF {
    double stictionSpeed = 100;         // 80;          // RPM
    double stictionReleaseSpeed = 120;  // RPM
    double stictionTorque = 0.0006;
+
+    uint16_t rampTime = 10;
  } rwHandlingParameters;

  struct RwMatrices {
@ -910,6 +912,7 @@ class AcsParameters : public HasParametersIF {
    double inverseAlignment[3][3] = {{0, -1, 0}, {0, 0, 1}, {-1, 0, 0}};
    double DipolMax = 0.2;  // [Am^2]

+    uint16_t torqueDuration = 300;  // [ms]
  } magnetorquesParameter;

  struct DetumbleParameter {
--- a/mission/controller/acs/ActuatorCmd.cpp
+++ b/mission/controller/acs/ActuatorCmd.cpp
@ -38,27 +38,33 @@ void ActuatorCmd::scalingTorqueRws(const double *rwTrq, double *rwTrqScaled) {
  }
 }

-void ActuatorCmd::cmdSpeedToRws(const int32_t *speedRw0, const int32_t *speedRw1,
-                                const int32_t *speedRw2, const int32_t *speedRw3,
-                                const double *rwTorque, double *rwCmdSpeed) {
+void ActuatorCmd::cmdSpeedToRws(const int32_t speedRw0, const int32_t speedRw1,
+                                const int32_t speedRw2, const int32_t speedRw3,
+                                const double *rwTorque, int32_t *rwCmdSpeed) {
  using namespace Math;

  // Calculating the commanded speed in RPM for every reaction wheel
-  double speedRws[4] = {(double)*speedRw0, (double)*speedRw1, (double)*speedRw2, (double)*speedRw3};
+  int32_t speedRws[4] = {speedRw0, speedRw1, speedRw2, speedRw3};
  double deltaSpeed[4] = {0, 0, 0, 0};
  double commandTime = acsParameters.onBoardParams.sampleTime,
         inertiaWheel = acsParameters.rwHandlingParameters.inertiaWheel;
  double radToRpm = 60 / (2 * PI);  // factor for conversion to RPM
  //	 W_RW = Torque_RW / I_RW * delta t [rad/s]
  double factor = commandTime / inertiaWheel * radToRpm;
+  int32_t deltaSpeedInt[4] = {0, 0, 0, 0};
  VectorOperations<double>::mulScalar(rwTorque, factor, deltaSpeed, 4);
-  VectorOperations<double>::add(speedRws, deltaSpeed, rwCmdSpeed, 4);
+  for (int i = 0; i < 4; i++) {
+    deltaSpeedInt[i] = std::round(deltaSpeed[i]);
+  }
+  VectorOperations<int32_t>::add(speedRws, deltaSpeedInt, rwCmdSpeed, 4);
+  VectorOperations<int32_t>::mulScalar(rwCmdSpeed, 10, rwCmdSpeed, 4);
 }

-void ActuatorCmd::cmdDipolMtq(const double *dipolMoment, double *dipolMomentActuator) {
+void ActuatorCmd::cmdDipolMtq(const double *dipolMoment, int16_t *dipolMomentActuator) {
  // Convert to actuator frame
+  double dipolMomentActuatorDouble[3] = {0, 0, 0};
  MatrixOperations<double>::multiply(*acsParameters.magnetorquesParameter.inverseAlignment,
-                                     dipolMoment, dipolMomentActuator, 3, 3, 1);
+                                     dipolMoment, dipolMomentActuatorDouble, 3, 3, 1);
  // Scaling along largest element if dipol exceeds maximum
  double maxDipol = acsParameters.magnetorquesParameter.DipolMax;
  double maxValue = 0;
@ -69,8 +75,12 @@ void ActuatorCmd::cmdDipolMtq(const double *dipolMoment, double *dipolMomentActu
  }
  if (maxValue > maxDipol) {
    double scalingFactor = maxDipol / maxValue;
-    VectorOperations<double>::mulScalar(dipolMomentActuator, scalingFactor, dipolMomentActuator, 3);
+    VectorOperations<double>::mulScalar(dipolMomentActuatorDouble, scalingFactor,
+                                        dipolMomentActuatorDouble, 3);
  }
  // scale dipole from 1 Am^2 to 1e^-4 Am^2
-  VectorOperations<double>::mulScalar(dipolMomentActuator, 1e4, dipolMomentActuator, 3);
+  VectorOperations<double>::mulScalar(dipolMomentActuatorDouble, 1e4, dipolMomentActuatorDouble, 3);
+  for (int i = 0; i < 3; i++) {
+    dipolMomentActuator[i] = std::round(dipolMomentActuatorDouble[i]);
+  }
 }
--- a/mission/controller/acs/ActuatorCmd.h
+++ b/mission/controller/acs/ActuatorCmd.h
@ -28,8 +28,8 @@ class ActuatorCmd {
   * 			rwCmdSpeed			output revolutions per minute for every
   * reaction wheel
   */
-  void cmdSpeedToRws(const int32_t *speedRw0, const int32_t *speedRw1, const int32_t *speedRw2,
-                     const int32_t *speedRw3, const double *rwTorque, double *rwCmdSpeed);
+  void cmdSpeedToRws(const int32_t speedRw0, const int32_t speedRw1, const int32_t speedRw2,
+                     const int32_t speedRw3, const double *rwTorque, int32_t *rwCmdSpeed);

  /*
   * @brief:	cmdDipolMtq()		gives the commanded dipol moment for the magnetorques
@ -37,7 +37,7 @@ class ActuatorCmd {
   * @param:	dipolMoment 		given dipol moment in spacecraft frame
   * 			dipolMomentActuator	resulting dipol moment in actuator reference frame
   */
-  void cmdDipolMtq(const double *dipolMoment, double *dipolMomentActuator);
+  void cmdDipolMtq(const double *dipolMoment, int16_t *dipolMomentActuator);

 protected:
 private:
--- a/mission/core/GenericFactory.cpp
+++ b/mission/core/GenericFactory.cpp
@ -4,6 +4,7 @@
 #include <fsfw/cfdp/handler/CfdpHandler.h>
 #include <fsfw/cfdp/handler/RemoteConfigTableIF.h>
 #include <fsfw/controller/ControllerBase.h>
+#include <fsfw/controller/ExtendedControllerBase.h>
 #include <fsfw/events/EventManager.h>
 #include <fsfw/health/HealthTable.h>
 #include <fsfw/internalerror/InternalErrorReporter.h>
@ -26,6 +27,10 @@
 #include <mission/controller/ThermalController.h>
 #include <mission/devices/HeaterHandler.h>
 #include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
+#include <mission/system/objects/AcsBoardAssembly.h>
+#include <mission/system/objects/RwAssembly.h>
+#include <mission/system/objects/SusAssembly.h>
+#include <mission/system/objects/TcsBoardAssembly.h>
 #include <mission/tmtc/CfdpTmFunnel.h>
 #include <mission/tmtc/PusTmFunnel.h>
 #include <mission/tmtc/TmFunnelHandler.h>
@ -35,6 +40,8 @@
 #include "eive/definitions.h"
 #include "fsfw/pus/Service11TelecommandScheduling.h"
 #include "mission/cfdp/Config.h"
+#include "mission/system/objects/RwAssembly.h"
+#include "mission/system/tree/acsModeTree.h"
 #include "mission/system/tree/tcsModeTree.h"
 #include "objects/systemObjectList.h"
 #include "tmtc/pusIds.h"
@ -218,3 +225,68 @@ void ObjectFactory::createThermalController(HeaterHandler& heaterHandler) {
  auto* tcsCtrl = new ThermalController(objects::THERMAL_CONTROLLER, heaterHandler);
  tcsCtrl->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
 }
+void ObjectFactory::createRwAssy(PowerSwitchIF& pwrSwitcher, power::Switch_t theSwitch,
+                                 std::array<DeviceHandlerBase*, 4> rws,
+                                 std::array<object_id_t, 4> rwIds) {
+  RwHelper rwHelper(rwIds);
+  auto* rwAss = new RwAssembly(objects::RW_ASS, &pwrSwitcher, theSwitch, rwHelper);
+  for (uint8_t idx = 0; idx < rwIds.size(); idx++) {
+    ReturnValue_t result = rws[idx]->connectModeTreeParent(*rwAss);
+    if (result != returnvalue::OK) {
+      sif::error << "Connecting RW " << static_cast<int>(idx) << " to RW assembly failed"
+                 << std::endl;
+    }
+  }
+  rwAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
+}
+
+void ObjectFactory::createSusAssy(PowerSwitchIF& pwrSwitcher,
+                                  std::array<DeviceHandlerBase*, 12> suses) {
+  std::array<object_id_t, 12> susIds = {
+      objects::SUS_0_N_LOC_XFYFZM_PT_XF,  objects::SUS_1_N_LOC_XBYFZM_PT_XB,
+      objects::SUS_2_N_LOC_XFYBZB_PT_YB,  objects::SUS_3_N_LOC_XFYBZF_PT_YF,
+      objects::SUS_4_N_LOC_XMYFZF_PT_ZF,  objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
+      objects::SUS_6_R_LOC_XFYBZM_PT_XF,  objects::SUS_7_R_LOC_XBYBZM_PT_XB,
+      objects::SUS_8_R_LOC_XBYBZB_PT_YB,  objects::SUS_9_R_LOC_XBYBZB_PT_YF,
+      objects::SUS_10_N_LOC_XMYBZF_PT_ZF, objects::SUS_11_R_LOC_XBYMZB_PT_ZB};
+  SusAssHelper susAssHelper = SusAssHelper(susIds);
+  auto susAss = new SusAssembly(objects::SUS_BOARD_ASS, &pwrSwitcher, susAssHelper);
+  for (auto& sus : suses) {
+    if (sus != nullptr) {
+      ReturnValue_t result = sus->connectModeTreeParent(*susAss);
+      if (result != returnvalue::OK) {
+        sif::error << "Connecting SUS " << sus->getObjectId() << " to SUS assembly failed"
+                   << std::endl;
+      }
+    }
+  }
+  susAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
+}
+
+void ObjectFactory::createAcsBoardAssy(PowerSwitchIF& pwrSwitcher,
+                                       std::array<DeviceHandlerBase*, 8> assemblyDhbs,
+                                       ExtendedControllerBase* gpsCtrl, GpioIF* gpioComIF) {
+  AcsBoardHelper acsBoardHelper = AcsBoardHelper(
+      objects::MGM_0_LIS3_HANDLER, objects::MGM_1_RM3100_HANDLER, objects::MGM_2_LIS3_HANDLER,
+      objects::MGM_3_RM3100_HANDLER, objects::GYRO_0_ADIS_HANDLER, objects::GYRO_1_L3G_HANDLER,
+      objects::GYRO_2_ADIS_HANDLER, objects::GYRO_3_L3G_HANDLER, objects::GPS_CONTROLLER);
+  auto acsAss =
+      new AcsBoardAssembly(objects::ACS_BOARD_ASS, &pwrSwitcher, acsBoardHelper, gpioComIF);
+  for (auto& assChild : assemblyDhbs) {
+    ReturnValue_t result = assChild->connectModeTreeParent(*acsAss);
+    if (result != returnvalue::OK) {
+      sif::error << "Connecting assembly for ACS board component " << assChild->getObjectId()
+                 << " failed" << std::endl;
+    }
+  }
+  gpsCtrl->connectModeTreeParent(*acsAss);
+  acsAss->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
+}
+
+TcsBoardAssembly* ObjectFactory::createTcsBoardAssy(PowerSwitchIF& pwrSwitcher) {
+  TcsBoardHelper helper(RTD_INFOS);
+  TcsBoardAssembly* tcsBoardAss = new TcsBoardAssembly(
+      objects::TCS_BOARD_ASS, &pwrSwitcher, pcdu::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
+  tcsBoardAss->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
+  return tcsBoardAss;
+}
--- a/mission/core/GenericFactory.h
+++ b/mission/core/GenericFactory.h
@ -1,13 +1,38 @@
 #ifndef MISSION_CORE_GENERICFACTORY_H_
 #define MISSION_CORE_GENERICFACTORY_H_

+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+#include "fsfw/objectmanager/SystemObjectIF.h"
 #include "fsfw/power/PowerSwitchIF.h"
 #include "fsfw_hal/common/gpio/GpioIF.h"
+#include "mission/devices/devicedefinitions/Max31865Definitions.h"

 class HeaterHandler;
 class HealthTableIF;
 class PusTmFunnel;
 class CfdpTmFunnel;
+class ExtendedControllerBase;
+class TcsBoardAssembly;
+
+const std::array<std::pair<object_id_t, std::string>, EiveMax31855::NUM_RTDS> RTD_INFOS = {{
+    {objects::RTD_0_IC3_PLOC_HEATSPREADER, "RTD_0_PLOC_HSPD"},
+    {objects::RTD_1_IC4_PLOC_MISSIONBOARD, "RTD_1_PLOC_MISSIONBRD"},
+    {objects::RTD_2_IC5_4K_CAMERA, "RTD_2_4K_CAMERA"},
+    {objects::RTD_3_IC6_DAC_HEATSPREADER, "RTD_3_DAC_HSPD"},
+    {objects::RTD_4_IC7_STARTRACKER, "RTD_4_STARTRACKER"},
+    {objects::RTD_5_IC8_RW1_MX_MY, "RTD_5_RW1_MX_MY"},
+    {objects::RTD_6_IC9_DRO, "RTD_6_DRO"},
+    {objects::RTD_7_IC10_SCEX, "RTD_7_SCEX"},
+    {objects::RTD_8_IC11_X8, "RTD_8_X8"},
+    {objects::RTD_9_IC12_HPA, "RTD_9_HPA"},
+    {objects::RTD_10_IC13_PL_TX, "RTD_10_PL_TX,"},
+    {objects::RTD_11_IC14_MPA, "RTD_11_MPA"},
+    {objects::RTD_12_IC15_ACU, "RTD_12_ACU"},
+    {objects::RTD_13_IC16_PLPCDU_HEATSPREADER, "RTD_13_PLPCDU_HSPD"},
+    {objects::RTD_14_IC17_TCS_BOARD, "RTD_14_TCS_BOARD"},
+    {objects::RTD_15_IC18_IMTQ, "RTD_15_IMTQ"},
+}};

 namespace ObjectFactory {

@ -17,6 +42,13 @@ void createGenericHeaterComponents(GpioIF& gpioIF, PowerSwitchIF& pwrSwitcher,
                                   HeaterHandler*& heaterHandler);

 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);
+void createAcsBoardAssy(PowerSwitchIF& pwrSwitcher, std::array<DeviceHandlerBase*, 8> assemblyDhbs,
+                        ExtendedControllerBase* gpsCtrl, GpioIF* gpioComIF);
+TcsBoardAssembly* createTcsBoardAssy(PowerSwitchIF& pwrSwitcher);
+
 }  // namespace ObjectFactory

 #endif /* MISSION_CORE_GENERICFACTORY_H_ */
--- a/mission/devices/BpxBatteryHandler.cpp
+++ b/mission/devices/BpxBatteryHandler.cpp
@ -2,8 +2,6 @@

 #include <fsfw/datapool/PoolReadGuard.h>

-#include "OBSWConfig.h"
-
 BpxBatteryHandler::BpxBatteryHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie)
    : DeviceHandlerBase(objectId, comIF, comCookie), hkSet(this), cfgSet(this) {}

@ -280,3 +278,9 @@ void BpxBatteryHandler::setToGoToNormalMode(bool enable) {
 }

 void BpxBatteryHandler::setDebugMode(bool enable) { this->debugMode = enable; }
+
+void BpxBatteryHandler::performOperationHook() {
+#if OBSW_THREAD_TRACING == 1
+  trace::threadTrace(opCounter, "BPX BATT");
+#endif
+}
--- a/mission/devices/BpxBatteryHandler.h
+++ b/mission/devices/BpxBatteryHandler.h
@ -4,6 +4,7 @@
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>

 #include "devicedefinitions/BpxBatteryDefinitions.h"
+#include "mission/trace.h"

 class BpxBatteryHandler : public DeviceHandlerBase {
 public:
@ -24,6 +25,10 @@ class BpxBatteryHandler : public DeviceHandlerBase {
  bool debugMode = false;
  bool goToNormalModeImmediately = false;
  uint8_t sentPingByte = BpxBattery::DEFAULT_PING_SENT_BYTE;
+#if OBSW_THREAD_TRACING == 1
+  uint32_t opCounter = 0;
+#endif
+
  BpxBatteryHk hkSet;
  DeviceCommandId_t lastCmd = DeviceHandlerIF::NO_COMMAND_ID;
  BpxBatteryCfg cfgSet;
@ -47,6 +52,7 @@ class BpxBatteryHandler : public DeviceHandlerBase {
  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
  void fillCommandAndReplyMap() override;
+  void performOperationHook() override;
  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
                                        size_t commandDataLen) override;
  ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId,
--- a/mission/devices/ImtqHandler.cpp
+++ b/mission/devices/ImtqHandler.cpp
@ -183,18 +183,20 @@ ReturnValue_t ImtqHandler::buildCommandFromCommand(DeviceCommandId_t deviceComma
        return DeviceHandlerIF::INVALID_COMMAND_PARAMETER;
      }
      ReturnValue_t result;
-      // Commands override anything which was set in the software
-      if (commandData != nullptr) {
-        dipoleSet.setValidityBufferGeneration(false);
-        result =
-            dipoleSet.deSerialize(&commandData, &commandDataLen, SerializeIF::Endianness::NETWORK);
-        dipoleSet.setValidityBufferGeneration(true);
-        if (result != returnvalue::OK) {
-          return result;
-        }
-      } else {
+      {
        // Read set dipole values from local pool
        PoolReadGuard pg(&dipoleSet);
+
+        // Commands override anything which was set in the software
+        if (commandData != nullptr) {
+          dipoleSet.setValidityBufferGeneration(false);
+          result = dipoleSet.deSerialize(&commandData, &commandDataLen,
+                                         SerializeIF::Endianness::NETWORK);
+          dipoleSet.setValidityBufferGeneration(true);
+          if (result != returnvalue::OK) {
+            return result;
+          }
+        }
      }
      if (ACTUATION_WIRETAPPING) {
        sif::debug << "Actuating IMTQ with parameters x = " << dipoleSet.xDipole.value
--- a/mission/devices/RwHandler.cpp
+++ b/mission/devices/RwHandler.cpp
@ -7,13 +7,15 @@
 #include "OBSWConfig.h"

 RwHandler::RwHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
-                     GpioIF* gpioComIF, gpioId_t enableGpio)
+                     GpioIF* gpioComIF, gpioId_t enableGpio, uint8_t rwIdx)
    : DeviceHandlerBase(objectId, comIF, comCookie),
      gpioComIF(gpioComIF),
      enableGpio(enableGpio),
      statusSet(this),
      lastResetStatusSet(this),
-      tmDataset(this) {
+      tmDataset(this),
+      rwSpeedActuationSet(*this),
+      rwIdx(rwIdx) {
  if (comCookie == nullptr) {
    sif::error << "RwHandler: Invalid com cookie" << std::endl;
  }
@ -42,6 +44,10 @@ void RwHandler::doShutDown() {

 ReturnValue_t RwHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
  switch (internalState) {
+    case InternalState::SET_SPEED:
+      *id = RwDefinitions::SET_SPEED;
+      internalState = InternalState::GET_RESET_STATUS;
+      break;
    case InternalState::GET_RESET_STATUS:
      *id = RwDefinitions::GET_LAST_RESET_STATUS;
      internalState = InternalState::READ_TEMPERATURE;
@ -52,7 +58,7 @@ ReturnValue_t RwHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
      break;
    case InternalState::GET_RW_SATUS:
      *id = RwDefinitions::GET_RW_STATUS;
-      internalState = InternalState::GET_RESET_STATUS;
+      internalState = InternalState::CLEAR_RESET_STATUS;
      break;
    case InternalState::CLEAR_RESET_STATUS:
      *id = RwDefinitions::CLEAR_LAST_RESET_STATUS;
@ -97,16 +103,37 @@ ReturnValue_t RwHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand
      return returnvalue::OK;
    }
    case (RwDefinitions::SET_SPEED): {
-      if (commandDataLen != 6) {
+      if (commandData != nullptr && commandDataLen != 6) {
        sif::error << "RwHandler::buildCommandFromCommand: Received set speed command with"
                   << " invalid length" << std::endl;
        return SET_SPEED_COMMAND_INVALID_LENGTH;
      }
-      result = checkSpeedAndRampTime(commandData, commandDataLen);
+
+      {
+        PoolReadGuard pg(&rwSpeedActuationSet);
+        // Commands override anything which was set in the software
+        if (commandData != nullptr) {
+          rwSpeedActuationSet.setValidityBufferGeneration(false);
+          result = rwSpeedActuationSet.deSerialize(&commandData, &commandDataLen,
+                                                   SerializeIF::Endianness::NETWORK);
+          rwSpeedActuationSet.setValidityBufferGeneration(true);
+          if (result != returnvalue::OK) {
+            return result;
+          }
+        }
+      }
+      if (ACTUATION_WIRETAPPING) {
+        int32_t speed = 0;
+        uint16_t rampTime = 0;
+        rwSpeedActuationSet.getRwSpeed(speed, rampTime);
+        sif::debug << "Actuating RW " << static_cast<int>(rwIdx) << " with speed = " << speed
+                   << " and rampTime = " << rampTime << std::endl;
+      }
+      result = checkSpeedAndRampTime();
      if (result != returnvalue::OK) {
        return result;
      }
-      prepareSetSpeedCmd(commandData, commandDataLen);
+      result = prepareSetSpeedCmd();
      return result;
    }
    case (RwDefinitions::GET_TEMPERATURE): {
@ -243,6 +270,9 @@ uint32_t RwHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { retur

 ReturnValue_t RwHandler::initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                                 LocalDataPoolManager& poolManager) {
+  localDataPoolMap.emplace(RwDefinitions::RW_SPEED, &rwSpeed);
+  localDataPoolMap.emplace(RwDefinitions::RAMP_TIME, &rampTime);
+
  localDataPoolMap.emplace(RwDefinitions::TEMPERATURE_C, new PoolEntry<int32_t>({0}));

  localDataPoolMap.emplace(RwDefinitions::CURR_SPEED, new PoolEntry<int32_t>({0}));
@ -295,17 +325,15 @@ void RwHandler::prepareSimpleCommand(DeviceCommandId_t id) {
  rawPacketLen = 3;
 }

-ReturnValue_t RwHandler::checkSpeedAndRampTime(const uint8_t* commandData, size_t commandDataLen) {
-  int32_t speed =
-      *commandData << 24 | *(commandData + 1) << 16 | *(commandData + 2) << 8 | *(commandData + 3);
-
+ReturnValue_t RwHandler::checkSpeedAndRampTime() {
+  int32_t speed = 0;
+  uint16_t rampTime = 0;
+  rwSpeedActuationSet.getRwSpeed(speed, rampTime);
  if ((speed < -65000 || speed > 65000 || (speed > -1000 && speed < 1000)) && (speed != 0)) {
    sif::error << "RwHandler::checkSpeedAndRampTime: Command has invalid speed" << std::endl;
    return INVALID_SPEED;
  }

-  uint16_t rampTime = (*(commandData + 4) << 8) | *(commandData + 5);
-
  if (rampTime < 10 || rampTime > 20000) {
    sif::error << "RwHandler::checkSpeedAndRampTime: Command has invalid ramp time" << std::endl;
    return INVALID_RAMP_TIME;
@ -314,23 +342,24 @@ ReturnValue_t RwHandler::checkSpeedAndRampTime(const uint8_t* commandData, size_
  return returnvalue::OK;
 }

-void RwHandler::prepareSetSpeedCmd(const uint8_t* commandData, size_t commandDataLen) {
+ReturnValue_t RwHandler::prepareSetSpeedCmd() {
  commandBuffer[0] = static_cast<uint8_t>(RwDefinitions::SET_SPEED);
-
-  /** Speed (0.1 RPM) */
-  commandBuffer[1] = *(commandData + 3);
-  commandBuffer[2] = *(commandData + 2);
-  commandBuffer[3] = *(commandData + 1);
-  commandBuffer[4] = *commandData;
-  /** Ramp time (ms) */
-  commandBuffer[5] = *(commandData + 5);
-  commandBuffer[6] = *(commandData + 4);
+  uint8_t* serPtr = commandBuffer + 1;
+  size_t serSize = 1;
+  rwSpeedActuationSet.setValidityBufferGeneration(false);
+  ReturnValue_t result = rwSpeedActuationSet.serialize(&serPtr, &serSize, sizeof(commandBuffer),
+                                                       SerializeIF::Endianness::LITTLE);
+  rwSpeedActuationSet.setValidityBufferGeneration(true);
+  if (result != returnvalue::OK) {
+    return result;
+  }

  uint16_t crc = CRC::crc16ccitt(commandBuffer, 7, 0xFFFF);
  commandBuffer[7] = static_cast<uint8_t>(crc & 0xFF);
-  commandBuffer[8] = static_cast<uint8_t>(crc >> 8 & 0xFF);
+  commandBuffer[8] = static_cast<uint8_t>((crc >> 8) & 0xFF);
  rawPacket = commandBuffer;
  rawPacketLen = 9;
+  return result;
 }

 void RwHandler::handleResetStatusReply(const uint8_t* packet) {
--- a/mission/devices/RwHandler.h
+++ b/mission/devices/RwHandler.h
@ -9,6 +9,8 @@
 #include "events/subsystemIdRanges.h"
 #include "returnvalues/classIds.h"

+static constexpr bool ACTUATION_WIRETAPPING = false;
+
 class GpioIF;

 /**
@ -34,7 +36,7 @@ class RwHandler : public DeviceHandlerBase {
   * 						to high to enable the device.
   */
  RwHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie, GpioIF* gpioComIF,
-            gpioId_t enableGpio);
+            gpioId_t enableGpio, uint8_t rwIdx);

  void setDebugMode(bool enable);

@ -93,10 +95,21 @@ class RwHandler : public DeviceHandlerBase {
  RwDefinitions::StatusSet statusSet;
  RwDefinitions::LastResetSatus lastResetStatusSet;
  RwDefinitions::TmDataset tmDataset;
+  RwDefinitions::RwSpeedActuationSet rwSpeedActuationSet;

  uint8_t commandBuffer[RwDefinitions::MAX_CMD_SIZE];
+  uint8_t rwIdx;

-  enum class InternalState { GET_RESET_STATUS, CLEAR_RESET_STATUS, READ_TEMPERATURE, GET_RW_SATUS };
+  PoolEntry<int32_t> rwSpeed = PoolEntry<int32_t>({0});
+  PoolEntry<uint16_t> rampTime = PoolEntry<uint16_t>({10});
+
+  enum class InternalState {
+    GET_RESET_STATUS,
+    CLEAR_RESET_STATUS,
+    READ_TEMPERATURE,
+    SET_SPEED,
+    GET_RW_SATUS
+  };

  InternalState internalState = InternalState::GET_RESET_STATUS;

@ -114,13 +127,14 @@ class RwHandler : public DeviceHandlerBase {
   *          range.
   * @return  returnvalue::OK if successful, otherwise error code.
   */
-  ReturnValue_t checkSpeedAndRampTime(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t checkSpeedAndRampTime();

  /**
-   * @brief   This function prepares the set speed command from the commandData received with
-   *          an action message.
+   * @brief   This function prepares the set speed command from the dataSet received with
+   *          an action message or set in the software.
+   * @return  returnvalue::OK if successful, otherwise error code.
   */
-  void prepareSetSpeedCmd(const uint8_t* commandData, size_t commandDataLen);
+  ReturnValue_t prepareSetSpeedCmd();

  /**
   * @brief   This function writes the last reset status retrieved with the get last reset status
--- a/mission/devices/SolarArrayDeploymentHandler.cpp
+++ b/mission/devices/SolarArrayDeploymentHandler.cpp
@ -11,6 +11,7 @@
 #include "fsfw/ipc/QueueFactory.h"
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw_hal/common/gpio/GpioCookie.h"
+#include "mission/trace.h"

 static constexpr bool DEBUG_MODE = true;

@ -37,6 +38,9 @@ SolarArrayDeploymentHandler::~SolarArrayDeploymentHandler() = default;

 ReturnValue_t SolarArrayDeploymentHandler::performOperation(uint8_t operationCode) {
  using namespace std::filesystem;
+#if OBSW_THREAD_TRACING == 1
+  trace::threadTrace(opCounter, "SA DEPL");
+#endif
  if (opDivider.checkAndIncrement()) {
    auto activeSdc = sdcMan.getActiveSdCard();
    if (activeSdc and activeSdc.value() == sd::SdCard::SLOT_0 and
--- a/mission/devices/SolarArrayDeploymentHandler.h
+++ b/mission/devices/SolarArrayDeploymentHandler.h
@ -19,6 +19,7 @@
 #include "fsfw/timemanager/Countdown.h"
 #include "fsfw_hal/common/gpio/GpioIF.h"
 #include "mission/memory/SdCardMountedIF.h"
+#include "mission/trace.h"
 #include "returnvalues/classIds.h"

 enum DeploymentChannels : uint8_t { SA_1 = 1, SA_2 = 2 };
@ -172,6 +173,9 @@ class SolarArrayDeploymentHandler : public ExecutableObjectIF,
  bool firstAutonomousCycle = true;
  ActionId_t activeCmd = HasActionsIF::INVALID_ACTION_ID;
  std::optional<uint64_t> initUptime;
+#if OBSW_THREAD_TRACING == 1
+  uint32_t opCounter = 0;
+#endif
  PeriodicOperationDivider opDivider = PeriodicOperationDivider(5);
  uint8_t retryCounter = 3;

--- a/mission/devices/devicedefinitions/RwDefinitions.h
+++ b/mission/devices/devicedefinitions/RwDefinitions.h
@ -51,7 +51,10 @@ enum PoolIds : lp_id_t {
  SPI_BYTES_WRITTEN,
  SPI_BYTES_READ,
  SPI_REG_OVERRUN_ERRORS,
-  SPI_TOTAL_ERRORS
+  SPI_TOTAL_ERRORS,
+
+  RW_SPEED,
+  RAMP_TIME,
 };

 enum States : uint8_t { STATE_ERROR, IDLE, COASTING, RUNNING_SPEED_STABLE, RUNNING_SPEED_CHANGING };
@ -75,10 +78,13 @@ static const DeviceCommandId_t SET_SPEED = 6;
 static const DeviceCommandId_t GET_TEMPERATURE = 8;
 static const DeviceCommandId_t GET_TM = 9;

-static const uint32_t TEMPERATURE_SET_ID = GET_TEMPERATURE;
-static const uint32_t STATUS_SET_ID = GET_RW_STATUS;
-static const uint32_t LAST_RESET_ID = GET_LAST_RESET_STATUS;
-static const uint32_t TM_SET_ID = GET_TM;
+enum SetIds : uint32_t {
+  TEMPERATURE_SET_ID = GET_TEMPERATURE,
+  STATUS_SET_ID = GET_RW_STATUS,
+  LAST_RESET_ID = GET_LAST_RESET_STATUS,
+  TM_SET_ID = GET_TM,
+  SPEED_CMD_SET = 10,
+};

 static const size_t SIZE_GET_RESET_STATUS = 5;
 static const size_t SIZE_CLEAR_RESET_STATUS = 4;
@ -106,9 +112,11 @@ static const uint8_t TM_SET_ENTRIES = 24;
 */
 class StatusSet : public StaticLocalDataSet<STATUS_SET_ENTRIES> {
 public:
-  StatusSet(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, STATUS_SET_ID) {}
+  StatusSet(HasLocalDataPoolIF* owner)
+      : StaticLocalDataSet(owner, RwDefinitions::SetIds::STATUS_SET_ID) {}

-  StatusSet(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, STATUS_SET_ID)) {}
+  StatusSet(object_id_t objectId)
+      : StaticLocalDataSet(sid_t(objectId, RwDefinitions::SetIds::STATUS_SET_ID)) {}

  lp_var_t<int32_t> temperatureCelcius =
      lp_var_t<int32_t>(sid.objectId, PoolIds::TEMPERATURE_C, this);
@ -124,9 +132,11 @@ class StatusSet : public StaticLocalDataSet<STATUS_SET_ENTRIES> {
 */
 class LastResetSatus : public StaticLocalDataSet<LAST_RESET_ENTRIES> {
 public:
-  LastResetSatus(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, LAST_RESET_ID) {}
+  LastResetSatus(HasLocalDataPoolIF* owner)
+      : StaticLocalDataSet(owner, RwDefinitions::SetIds::LAST_RESET_ID) {}

-  LastResetSatus(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, LAST_RESET_ID)) {}
+  LastResetSatus(object_id_t objectId)
+      : StaticLocalDataSet(sid_t(objectId, RwDefinitions::SetIds::LAST_RESET_ID)) {}

  // If a reset occurs, the status code will be cached into this variable
  lp_var_t<uint8_t> lastNonClearedResetStatus =
@ -143,9 +153,11 @@ class LastResetSatus : public StaticLocalDataSet<LAST_RESET_ENTRIES> {
 */
 class TmDataset : public StaticLocalDataSet<TM_SET_ENTRIES> {
 public:
-  TmDataset(HasLocalDataPoolIF* owner) : StaticLocalDataSet(owner, TM_SET_ID) {}
+  TmDataset(HasLocalDataPoolIF* owner)
+      : StaticLocalDataSet(owner, RwDefinitions::SetIds::TM_SET_ID) {}

-  TmDataset(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, TM_SET_ID)) {}
+  TmDataset(object_id_t objectId)
+      : StaticLocalDataSet(sid_t(objectId, RwDefinitions::SetIds::TM_SET_ID)) {}

  lp_var_t<uint8_t> lastResetStatus =
      lp_var_t<uint8_t>(sid.objectId, PoolIds::TM_LAST_RESET_STATUS, this);
@ -192,6 +204,36 @@ class TmDataset : public StaticLocalDataSet<TM_SET_ENTRIES> {
      lp_var_t<uint32_t>(sid.objectId, PoolIds::SPI_TOTAL_ERRORS, this);
 };

+class RwSpeedActuationSet : public StaticLocalDataSet<2> {
+  friend class RwHandler;
+
+ public:
+  RwSpeedActuationSet(HasLocalDataPoolIF& owner)
+      : StaticLocalDataSet(&owner, RwDefinitions::SetIds::SPEED_CMD_SET) {}
+  RwSpeedActuationSet(object_id_t objectId)
+      : StaticLocalDataSet(sid_t(objectId, RwDefinitions::SetIds::SPEED_CMD_SET)) {}
+
+  void setRwSpeed(int32_t rwSpeed_, uint16_t rampTime_) {
+    if (rwSpeed.value != rwSpeed_) {
+      rwSpeed = rwSpeed_;
+    }
+    if (rampTime.value != rampTime_) {
+      rampTime = rampTime_;
+    }
+  }
+
+  void getRwSpeed(int32_t& rwSpeed_, uint16_t& rampTime_) {
+    rwSpeed_ = rwSpeed.value;
+    rampTime_ = rampTime.value;
+  }
+
+ private:
+  lp_var_t<int32_t> rwSpeed =
+      lp_var_t<int32_t>(sid.objectId, RwDefinitions::PoolIds::RW_SPEED, this);
+  lp_var_t<uint16_t> rampTime =
+      lp_var_t<uint16_t>(sid.objectId, RwDefinitions::PoolIds::RAMP_TIME, this);
+};
+
 }  // namespace RwDefinitions

 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_RWDEFINITIONS_H_ */
--- a/mission/devices/devicedefinitions/imtqHandlerDefinitions.h
+++ b/mission/devices/devicedefinitions/imtqHandlerDefinitions.h
@ -492,14 +492,14 @@ class DipoleActuationSet : public StaticLocalDataSet<4> {
  void setDipoles(int16_t xDipole_, int16_t yDipole_, int16_t zDipole_,
                  uint16_t currentTorqueDurationMs_) {
    if (xDipole.value != xDipole_) {
+      xDipole = xDipole_;
    }
-    xDipole = xDipole_;
    if (yDipole.value != yDipole_) {
+      yDipole = yDipole_;
    }
-    yDipole = yDipole_;
    if (zDipole.value != zDipole_) {
+      zDipole = zDipole_;
    }
-    zDipole = zDipole_;
    currentTorqueDurationMs = currentTorqueDurationMs_;
  }

--- a/mission/trace.cpp
+++ b/mission/trace.cpp
@ -0,0 +1,10 @@
+#include "trace.h"
+
+#include "fsfw/serviceinterface.h"
+
+void trace::threadTrace(uint32_t& counter, const char* name, unsigned div) {
+  counter++;
+  if (counter % div == 0) {
+    sif::debug << name << " running" << std::endl;
+  }
+}
--- a/mission/trace.h
+++ b/mission/trace.h
@ -0,0 +1,14 @@
+#ifndef MISSION_TRACE_H_
+#define MISSION_TRACE_H_
+
+#include <cstdint>
+
+#define OBSW_THREAD_TRACING 0
+
+namespace trace {
+
+void threadTrace(uint32_t& counter, const char* name, unsigned div = 5);
+
+}
+
+#endif /* MISSION_TRACE_H_ */
--- a/scripts/q7s-em-udp-forwarding.sh
+++ b/scripts/q7s-em-udp-forwarding.sh
@ -0,0 +1,7 @@
+#!/bin/bash
+echo "Q7S UDP connection from local port 18000 -> TCP ssh tunnel -> EM port 7301"
+
+
+socat udp4-listen:18000,reuseaddr,fork tcp:localhost:18002 &
+ssh -L 18002:localhost:18123 eive@flatsat.eive.absatvirt.lw \
+	'socat tcp4-listen:18123,reuseaddr udp:192.168.133.10:7301'
--- a/scripts/q7s-fm-udp-forwarding.sh
+++ b/scripts/q7s-fm-udp-forwarding.sh
@ -0,0 +1,7 @@
+#!/bin/bash
+echo "Q7S UDP connection from local port 18000 -> TCP ssh tunnel -> FM port 7301"
+
+
+socat udp4-listen:18000,reuseaddr,fork tcp:localhost:18002 &
+ssh -L 18002:localhost:18123 eive@flatsat.eive.absatvirt.lw \
+	'socat tcp4-listen:18123,reuseaddr udp:192.168.155.55:7301'
--- a/scripts/q7s-ssh-udp-forwarding.sh
+++ b/scripts/q7s-ssh-udp-forwarding.sh
@ -1,8 +0,0 @@
-#!/bin/bash
-echo "Setting up all Q7S ports"
-echo "upd connection from local port 18000 -> tcp ssh tunnel -> EM port 7301"
-
-
-socat udp4-listen:18000,reuseaddr,fork tcp:localhost:18002 &
-ssh -L 18002:localhost:18123 eive@flatsat.eive.absatvirt.lw 'socat tcp4-listen:18123,reuseaddr udp:192.168.133.10:7301'
-
--- a/test/TestTask.cpp
+++ b/test/TestTask.cpp
@ -41,11 +41,13 @@ ReturnValue_t EiveTestTask::performOperation(uint8_t operationCode) {
 }

 #include <etl/vector.h>
-#include <lwgps/lwgps.h>
+
+// #include <lwgps/lwgps.h>

 /**
 * @brief           Dummy data from GPS receiver. Will be replaced witgh hyperion data later.
 */
+
 const char gps_rx_data[] =
    ""
    "$GPRMC,183729,A,3907.356,N,12102.482,W,000.0,360.0,080301,015.5,E*6F\r\n"
@ -96,20 +98,22 @@ ReturnValue_t EiveTestTask::performActionB() {
  return result;
 }

+/*
 void EiveTestTask::performLwgpsTest() {
-  /* Everything here will only be performed once. */
+  // Everything here will only be performed once.
  sif::info << "Processing sample GPS output.." << std::endl;

  lwgps_t gpsStruct;
  sif::info << "Size of GPS struct: " << sizeof(gpsStruct) << std::endl;
  lwgps_init(&gpsStruct);

-  /* Process all input data */
+  // Process all input data
  lwgps_process(&gpsStruct, hyperion_gps_data, strlen(hyperion_gps_data));

-  /* Print messages */
+  // Print messages
  printf("Valid status: %d\n", gpsStruct.is_valid);
  printf("Latitude: %f degrees\n", gpsStruct.latitude);
  printf("Longitude: %f degrees\n", gpsStruct.longitude);
  printf("Altitude: %f meters\n", gpsStruct.altitude);
 }
+*/
--- a/thirdparty/lwgps
+++ b/thirdparty/lwgps
--- a/2
+++ b/2
Author	SHA1	Message	Date
Robin Mueller	177b573cd4	prep v1.27.2 All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details	2023-02-14 18:54:43 +01:00
Robin Müller	1553900145	Merge pull request 'Enable ACS Controller to command RWs' (#375 ) from eggert/rw-cmd-acs-ctrl into develop All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details Reviewed-on: #375	2023-02-14 18:53:01 +01:00
Robin Mueller	166fd77f7b	stupid RW All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-14 18:41:43 +01:00
Robin Mueller	29e78a7ae3	Merge remote-tracking branch 'origin/develop' into eggert/rw-cmd-acs-ctrl All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-14 17:33:37 +01:00
Robin Müller	a893618f60	Merge pull request 'Thread Tracing and Scheduling Update' (#379 ) from thread_tracing into develop All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details Reviewed-on: #379 Reviewed-by: Marius Eggert <eggertm@irs.uni-stuttgart.de>	2023-02-14 15:59:11 +01:00
Robin Mueller	918cd7b237	small tweak for scripts, bump fsfw All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details	2023-02-14 14:38:33 +01:00
Robin Mueller	d506b515fc	bump fsfw All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-14 14:33:12 +01:00
Robin Mueller	6f84099c5e	small update and afmt All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-14 14:29:47 +01:00
Robin Mueller	024e06a3d3	set define to 0 for PR All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-14 14:28:26 +01:00
Robin Mueller	35b9c7a4df	bump changelog All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-14 14:27:25 +01:00
Robin Mueller	fd9503ed3b	Merge remote-tracking branch 'origin/develop' into thread_tracing Some checks are pending EIVE/eive-obsw/pipeline/head Build started... Details EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-14 14:23:49 +01:00
Robin Mueller	0654001945	Merge remote-tracking branch 'origin/develop' into eggert/rw-cmd-acs-ctrl All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-14 14:15:56 +01:00
Robin Mueller	a0d09e7f23	go away All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details	2023-02-14 14:15:30 +01:00
Robin Mueller	e07492c855	bump tmtc Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-14 14:10:37 +01:00
Robin Mueller	92b3f740d5	Merge remote-tracking branch 'origin/develop' into eggert/rw-cmd-acs-ctrl	2023-02-14 14:10:21 +01:00
Robin Mueller	16eab6b266	update forwarding scripts for UDP Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-14 14:01:16 +01:00
Robin Mueller	1de832509a	do a commit Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-14 13:40:07 +01:00
Robin Mueller	ef09cdabc2	remove lwgps properly Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-14 13:15:12 +01:00
Robin Mueller	3da5f1d6cc	update .cproject file Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-14 13:13:16 +01:00
Robin Mueller	e0c33b21e9	remove lwgps dependency Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-14 13:11:52 +01:00
Robin Mueller	2d4c881d3a	add missing include Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-14 11:56:40 +01:00
meggert	56840deb9b	Merge branch 'develop' into eggert/rw-cmd-acs-ctrl Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-14 11:51:38 +01:00
Robin Mueller	ecb22bdd85	further cut down the number of threads Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-14 11:32:03 +01:00
Robin Mueller	9b2398888d	add some more traces Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-14 11:18:51 +01:00
Robin Mueller	a57384f6c4	trace has settable div Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-14 11:11:06 +01:00
Robin Mueller	2aac3c67ee	instrumented some more tasks Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-14 11:10:18 +01:00
Robin Mueller	66d20dc118	add tracing for first tasks Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-14 10:59:35 +01:00
Robin Mueller	a75e035cc5	fix cppcheck lints Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-14 10:36:53 +01:00
Robin Mueller	3c5a2568ef	updatr lwgps dependency Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-14 10:24:43 +01:00
Robin Mueller	131fff6847	update create dummeis All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details	2023-02-14 10:02:12 +01:00
Marius Eggert	d9acbe3207	Merge pull request 'Make satsystem work on EM' (#377 ) from make_satsyste_work_on_em into develop Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details Reviewed-on: #377 Reviewed-by: Marius Eggert <eggertm@irs.uni-stuttgart.de>	2023-02-13 18:04:01 +01:00
meggert	4ba0d36800	Merge remote-tracking branch 'origin/develop' into make_satsyste_work_on_em Some checks are pending EIVE/eive-obsw/pipeline/pr-develop Build started... Details	2023-02-13 18:01:20 +01:00
meggert	6a1d4bd52f	continue	2023-02-13 18:01:16 +01:00
meggert	4cccafbe01	no error im happy Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-13 17:59:08 +01:00
meggert	f5092b27ba	add SCEX dummy Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-13 17:24:56 +01:00
Robin Mueller	17fa9a6e82	add TCS board assy for EM Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-13 17:04:04 +01:00
meggert	2813d229bb	comntinue Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-13 16:39:26 +01:00
Robin Mueller	6c0234149e	compile fixes Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-13 16:19:14 +01:00
meggert	99913594fd	rfrmt All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-13 16:10:58 +01:00
meggert	f864d73253	Merge branch 'develop' into eggert/rw-cmd-acs-ctrl	2023-02-13 16:06:46 +01:00
Marius Eggert	af8caca3f6	Merge pull request 'lets see if this fixes issues' (#378 ) from refactor_tcs_acs_and_scheduling into develop All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details Reviewed-on: #378 Reviewed-by: Marius Eggert <eggertm@irs.uni-stuttgart.de>	2023-02-13 16:00:44 +01:00
Robin Mueller	e2f8ca752f	continue satsystem Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-13 15:59:44 +01:00
Robin Mueller	efbb5d69c7	remove removed task start All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-13 15:44:19 +01:00
Robin Mueller	ebc32d1cc2	changelog Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-13 15:42:45 +01:00
Robin Mueller	b4d9ea6c19	lets see if this fixes issues Some checks failed EIVE/eive-obsw/pipeline/head There was a failure building this commit Details	2023-02-13 15:37:42 +01:00
Robin Mueller	323140c846	bump revision All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details	2023-02-13 14:19:24 +01:00
Robin Mueller	cec9ef6c5d	some fixes All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details	2023-02-13 14:19:07 +01:00
Robin Mueller	97a001a1da	continue satsytem for EM Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-13 13:53:13 +01:00
Robin Mueller	59a0a74032	start adding assy components for EM All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-13 11:49:26 +01:00
meggert	068b31a3d6	changelog All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-13 11:07:09 +01:00
meggert	1d20c3b472	changelog All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-13 11:04:43 +01:00
meggert	14c43c49dc	scale rwCmdSpeed to appropriate range	2023-02-13 10:58:12 +01:00
meggert	53f31ca5a4	lol All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-13 10:42:05 +01:00
Robin Mueller	b5e096abcb	start work on EM satsystem All checks were successful EIVE/eive-obsw/pipeline/head This commit looks good Details	2023-02-13 10:40:39 +01:00
meggert	f4f6d1ed81	added InternalState SET_SPEED to enable setting RW Speed from ACS Ctrl	2023-02-13 10:33:08 +01:00
meggert	ac22a00e09	Merge branch 'develop' into eggert/rw-cmd-acs-ctrl	2023-02-13 10:29:56 +01:00
meggert	35172185f9	fix All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-10 13:29:13 +01:00
meggert	fc5196f8da	Merge branch 'develop' into eggert/rw-cmd-acs-ctrl All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-10 13:23:58 +01:00
meggert	285bd7116b	bump changelog	2023-02-10 13:17:52 +01:00
meggert	08df102f36	rwHandler rwSpeedActuationSet handling	2023-02-10 13:16:50 +01:00
meggert	33684f2ef7	fixed imtq setDipoles check Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-10 12:48:17 +01:00
meggert	bc4c6c3a54	changelog Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-10 12:07:45 +01:00
meggert	109560feb2	disabled actCmd from acsCtrl again for now Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-10 11:30:52 +01:00
meggert	ea32d87c25	function now handles actuator cmd All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-10 11:27:25 +01:00
meggert	01d6060111	added ramp time	2023-02-10 11:27:02 +01:00
meggert	c2079dcbba	added rampTime and made dataSet public	2023-02-10 11:26:46 +01:00
meggert	9041a3376c	ActuatorCmd now output their solutions as integers as expected by the sensors Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-10 10:56:50 +01:00
meggert	9dfd8491d2	added rampTime and torqueDuration to AcsParameters All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-10 10:25:13 +01:00
meggert	51629da4a0	naming fixes All checks were successful EIVE/eive-obsw/pipeline/pr-develop This commit looks good Details	2023-02-09 17:55:20 +01:00
meggert	a3eaace4a5	added RwSpeedActuationSets to AcsController Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-09 17:31:26 +01:00
meggert	5a5d00e4e5	dataPool for setting RW speeds Some checks failed EIVE/eive-obsw/pipeline/pr-develop There was a failure building this commit Details	2023-02-09 17:11:23 +01:00