Merge remote-tracking branch 'origin/develop' into mueller/pus-15-tm-storage

linux/ObjectFactory.cpp

@@ -363,6 +363,6 @@ void ObjectFactory::gpioChecker(ReturnValue_t result, std::string output) {
 
 void ObjectFactory::addTmtcIpCoresToFunnels(CcsdsIpCoreHandler& ipCoreHandler,
                                             PusTmFunnel& pusFunnel, CfdpTmFunnel& cfdpFunnel) {
-  cfdpFunnel.addDestination(ipCoreHandler, config::LIVE_TM);
-  pusFunnel.addDestination(ipCoreHandler, config::LIVE_TM);
+  cfdpFunnel.addDestination("PTME IP Core", ipCoreHandler, config::LIVE_TM);
+  pusFunnel.addDestination("PTME IP Core", ipCoreHandler, config::LIVE_TM);
 }

linux/devices/GpsHyperionLinuxController.cpp

@@ -34,7 +34,6 @@ ReturnValue_t GpsHyperionLinuxController::checkModeCommand(Mode_t mode, Submode_
                                                            uint32_t *msToReachTheMode) {
   if (not modeCommanded) {
     if (mode == MODE_ON or mode == MODE_OFF) {
-      gpsNotOpenSwitch = true;
       // 5h time to reach fix
       *msToReachTheMode = MAX_SECONDS_TO_REACH_FIX;
       maxTimeToReachFix.resetTimer();
@@ -44,7 +43,12 @@ ReturnValue_t GpsHyperionLinuxController::checkModeCommand(Mode_t mode, Submode_
     }
   }
   if (mode == MODE_OFF) {
+    PoolReadGuard pg(&gpsSet);
     gpsSet.setValidity(false, true);
+    // There can't be a fix with a device that is off.
+    triggerEvent(GpsHyperion::GPS_FIX_CHANGE, gpsSet.fixMode.value, 0);
+    oneShotSwitches.reset();
+    modeCommanded = false;
   }
   return returnvalue::OK;
 }
@@ -101,6 +105,7 @@ ReturnValue_t GpsHyperionLinuxController::performOperation(uint8_t opCode) {
     if (not callAgainImmediately) {
       handleQueue();
       poolManager.performHkOperation();
+      TaskFactory::delayTask(250);
     }
   }
   // Should never be reached.
@@ -113,25 +118,24 @@ ReturnValue_t GpsHyperionLinuxController::initialize() {
     return result;
   }
   auto openError = [&](const char *type, int error) {
-    if (gpsNotOpenSwitch) {
-      // Opening failed
+  // Opening failed
 #if FSFW_VERBOSE_LEVEL >= 1
-      sif::warning << "GPSHyperionHandler::readGpsDataFromGpsd: Opening GPSMM " << type
-                   << " failed | Error " << error << " | " << gps_errstr(error) << std::endl;
+    sif::warning << "GPSHyperionHandler::readGpsDataFromGpsd: Opening GPSMM " << type
+                 << " failed | Error " << error << " | " << gps_errstr(error) << std::endl;
 #endif
-      gpsNotOpenSwitch = false;
-    }
   };
   if (readMode == ReadModes::SOCKET) {
     int retval = gps_open("localhost", DEFAULT_GPSD_PORT, &gps);
     if (retval != 0) {
       openError("Socket", retval);
+      return ObjectManager::CHILD_INIT_FAILED;
     }
     gps_stream(&gps, WATCH_ENABLE | WATCH_JSON, nullptr);
   } else if (readMode == ReadModes::SHM) {
     int retval = gps_open(GPSD_SHARED_MEMORY, "", &gps);
     if (retval != 0) {
       openError("SHM", retval);
+      return ObjectManager::CHILD_INIT_FAILED;
     }
   }
   return result;
@@ -145,32 +149,33 @@ void GpsHyperionLinuxController::performControlOperation() {}
 
 bool GpsHyperionLinuxController::readGpsDataFromGpsd() {
   auto readError = [&]() {
-    if (gpsReadFailedSwitch) {
-      gpsReadFailedSwitch = false;
+    if (oneShotSwitches.gpsReadFailedSwitch) {
+      oneShotSwitches.gpsReadFailedSwitch = false;
       sif::warning << "GPSHyperionHandler::readGpsDataFromGpsd: Reading GPS data failed | "
                       "Error "
                    << errno << " | " << gps_errstr(errno) << std::endl;
     }
   };
+  // GPS is off, no point in reading data from GPSD.
+  if (mode == MODE_OFF) {
+    return false;
+  }
   if (readMode == ReadModes::SOCKET) {
-    // Perform other necessary handling if not data seen for 0.2 seconds.
-    if (gps_waiting(&gps, 200000)) {
+    // Poll the GPS.
+    if (gps_waiting(&gps, 0)) {
       if (-1 == gps_read(&gps)) {
         readError();
         return false;
       }
+      oneShotSwitches.gpsReadFailedSwitch = true;
       if (MODE_SET != (MODE_SET & gps.set)) {
-        if (mode == MODE_ON) {
-          if (noModeSetCntr >= 0) {
-            noModeSetCntr++;
-          }
-          if (noModeSetCntr == 10) {
-            // TODO: Trigger event here
-            sif::warning << "GPSHyperionHandler::readGpsDataFromGpsd: No mode could be "
-                            "read for 10 consecutive reads"
-                         << std::endl;
-            noModeSetCntr = -1;
-          }
+        if (mode != MODE_OFF and maxTimeToReachFix.hasTimedOut() and
+            oneShotSwitches.cantGetFixSwitch) {
+          sif::warning
+              << "GPSHyperionHandler::readGpsDataFromGpsd: No mode could be set in allowed "
+              << maxTimeToReachFix.timeout / 1000 << " seconds" << std::endl;
+          triggerEvent(GpsHyperion::CANT_GET_FIX, maxTimeToReachFix.timeout);
+          oneShotSwitches.cantGetFixSwitch = false;
           // did not event get mode, nothing to see.
           return false;
         }
@@ -198,51 +203,58 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
   }
 
   bool validFix = false;
-  static_cast<void>(validFix);
   // 0: Not seen, 1: No fix, 2: 2D-Fix, 3: 3D-Fix
-  int newFixMode = gps.fix.mode;
-  if (newFixMode == 2 or newFixMode == 3) {
+  if (gps.fix.mode == 2 or gps.fix.mode == 3) {
     validFix = true;
   }
-  if (gpsSet.fixMode.value != newFixMode) {
-    triggerEvent(GpsHyperion::GPS_FIX_CHANGE, gpsSet.fixMode.value, newFixMode);
+  if (gpsSet.fixMode.value != gps.fix.mode) {
+    triggerEvent(GpsHyperion::GPS_FIX_CHANGE, gpsSet.fixMode.value, gps.fix.mode);
   }
-  gpsSet.fixMode.value = newFixMode;
+  gpsSet.fixMode.value = gps.fix.mode;
   if (gps.fix.mode == 0 or gps.fix.mode == 1) {
     if (modeCommanded and maxTimeToReachFix.hasTimedOut()) {
-      // We are supposed to be on and functioning, but not fix was found
+      // We are supposed to be on and functioning, but no fix was found
       if (mode == MODE_ON or mode == MODE_NORMAL) {
         mode = MODE_OFF;
       }
       modeCommanded = false;
     }
     gpsSet.setValidity(false, true);
-  } else if (gps.satellites_used > 0) {
+  } else if (gps.satellites_used > 0 && validFix && mode != MODE_OFF) {
     gpsSet.setValidity(true, true);
   }
 
   gpsSet.satInUse.value = gps.satellites_used;
   gpsSet.satInView.value = gps.satellites_visible;
 
+  bool latValid = false;
   if (std::isfinite(gps.fix.latitude)) {
     // Negative latitude -> South direction
     gpsSet.latitude.value = gps.fix.latitude;
-  } else {
-    gpsSet.latitude.setValid(false);
+    if (gps.fix.mode >= 2) {
+      latValid = true;
+    }
   }
+  gpsSet.latitude.setValid(latValid);
 
+  bool longValid = false;
   if (std::isfinite(gps.fix.longitude)) {
     // Negative longitude -> West direction
     gpsSet.longitude.value = gps.fix.longitude;
-  } else {
-    gpsSet.longitude.setValid(false);
+    if (gps.fix.mode >= 2) {
+      longValid = true;
+    }
   }
+  gpsSet.latitude.setValid(longValid);
 
+  bool altitudeValid = false;
   if (std::isfinite(gps.fix.altitude)) {
     gpsSet.altitude.value = gps.fix.altitude;
-  } else {
-    gpsSet.altitude.setValid(false);
+    if (gps.fix.mode == 3) {
+      altitudeValid = true;
+    }
   }
+  gpsSet.altitude.setValid(altitudeValid);
 
   if (std::isfinite(gps.fix.speed)) {
     gpsSet.speed.value = gps.fix.speed;
@@ -250,59 +262,44 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
     gpsSet.speed.setValid(false);
   }
 
+  if (TIME_SET == (TIME_SET & gps.set)) {
+    timeval time = {};
 #if LIBGPS_VERSION_MINOR <= 17
-  gpsSet.unixSeconds.value = gps.fix.time;
+    gpsSet.unixSeconds.value = std::floor(gps.fix.time);
+    double fractionalPart = gps.fix.time - gpsSet.unixSeconds.value;
+    time.tv_usec = fractionalPart * 1000.0 * 1000.0;
 #else
-  gpsSet.unixSeconds.value = gps.fix.time.tv_sec;
+    gpsSet.unixSeconds.value = gps.fix.time.tv_sec;
+    time.tv_usec = gps.fix.time.tv_nsec / 1000;
 #endif
-  timeval time = {};
-  time.tv_sec = gpsSet.unixSeconds.value;
-#if LIBGPS_VERSION_MINOR <= 17
-  double fractionalPart = gps.fix.time - std::floor(gps.fix.time);
-  time.tv_usec = fractionalPart * 1000.0 * 1000.0;
-#else
-  time.tv_usec = gps.fix.time.tv_nsec / 1000;
-#endif
-  std::time_t t = std::time(nullptr);
-  if (time.tv_sec == t) {
-    timeIsConstantCounter++;
+    time.tv_sec = gpsSet.unixSeconds.value;
+    // If the time is totally wrong (e.g. year 2000 after system reset because we do not have a RTC
+    // and no time file available) we set it with the roughly valid time from the GPS.
+    // NTP might only work if the time difference between sys time and current time is not too
+    // large.
+    overwriteTimeIfNotSane(time, validFix);
+    Clock::TimeOfDay_t timeOfDay = {};
+    Clock::convertTimevalToTimeOfDay(&time, &timeOfDay);
+    gpsSet.year = timeOfDay.year;
+    gpsSet.month = timeOfDay.month;
+    gpsSet.day = timeOfDay.day;
+    gpsSet.hours = timeOfDay.hour;
+    gpsSet.minutes = timeOfDay.minute;
+    gpsSet.seconds = timeOfDay.second;
   } else {
-    timeIsConstantCounter = 0;
-  }
-  if (timeInit and validFix) {
-    if (not utility::timeSanityCheck()) {
-#if OBSW_VERBOSE_LEVEL >= 1
-      time_t timeRaw = time.tv_sec;
-      std::tm *timeTm = std::gmtime(&timeRaw);
-      sif::info << "Setting invalid system time from GPS data directly: "
-                << std::put_time(timeTm, "%c %Z") << std::endl;
-#endif
-      // For some reason, the clock needs to be somewhat correct for NTP to work. Really dumb..
-      Clock::setClock(&time);
-    }
-    timeInit = false;
-  }
-  // If the received time does not change anymore for whatever reason, do not set it here
-  // to avoid stale times. Also, don't do it too often often to avoid jumping times
-  if (timeIsConstantCounter < 20 and timeUpdateCd.hasTimedOut()) {
-    // Update the system time here for now. NTP seems to be unable to do so for whatever reason.
-    // Further tests have shown that the time seems to be set by NTPD after some time..
-    // Clock::setClock(&time);
-    timeUpdateCd.resetTimer();
+    gpsSet.unixSeconds.setValid(false);
+    gpsSet.year.setValid(false);
+    gpsSet.month.setValid(false);
+    gpsSet.day.setValid(false);
+    gpsSet.hours.setValid(false);
+    gpsSet.minutes.setValid(false);
+    gpsSet.seconds.setValid(false);
   }
 
-  Clock::TimeOfDay_t timeOfDay = {};
-  Clock::convertTimevalToTimeOfDay(&time, &timeOfDay);
-  gpsSet.year = timeOfDay.year;
-  gpsSet.month = timeOfDay.month;
-  gpsSet.day = timeOfDay.day;
-  gpsSet.hours = timeOfDay.hour;
-  gpsSet.minutes = timeOfDay.minute;
-  gpsSet.seconds = timeOfDay.second;
   if (debugHyperionGps) {
     sif::info << "-- Hyperion GPS Data --" << std::endl;
 #if LIBGPS_VERSION_MINOR <= 17
-    time_t timeRaw = gps.fix.time;
+    time_t timeRaw = gpsSet.unixSeconds.value;
 #else
     time_t timeRaw = gps.fix.time.tv_sec;
 #endif
@@ -325,3 +322,19 @@ ReturnValue_t GpsHyperionLinuxController::handleGpsReadData() {
   }
   return returnvalue::OK;
 }
+
+void GpsHyperionLinuxController::overwriteTimeIfNotSane(timeval time, bool validFix) {
+  if (not timeInit and validFix) {
+    if (not utility::timeSanityCheck()) {
+#if OBSW_VERBOSE_LEVEL >= 1
+      time_t timeRaw = time.tv_sec;
+      std::tm *timeTm = std::gmtime(&timeRaw);
+      sif::info << "Overwriting invalid system time from GPS data directly: "
+                << std::put_time(timeTm, "%c %Z") << std::endl;
+#endif
+      // For some reason, the clock needs to be somewhat correct for NTP to work. Really dumb..
+      Clock::setClock(&time);
+    }
+    timeInit = true;
+  }
+}

linux/devices/GpsHyperionLinuxController.h

@@ -58,18 +58,30 @@ class GpsHyperionLinuxController : public ExtendedControllerBase {
   const char* currentClientBuf = nullptr;
   ReadModes readMode = ReadModes::SOCKET;
   Countdown maxTimeToReachFix = Countdown(MAX_SECONDS_TO_REACH_FIX * 1000);
-  bool modeCommanded = true;
-  bool timeInit = true;
-  bool gpsNotOpenSwitch = true;
-  bool gpsReadFailedSwitch = true;
+  bool modeCommanded = false;
+  bool timeInit = false;
+
+  struct OneShotSwitches {
+    void reset() {
+      gpsReadFailedSwitch = true;
+      cantGetFixSwitch = true;
+    }
+    bool gpsReadFailedSwitch = true;
+    bool cantGetFixSwitch = true;
+
+  } oneShotSwitches;
+
   bool debugHyperionGps = false;
   int32_t noModeSetCntr = 0;
-  uint32_t timeIsConstantCounter = 0;
   Countdown timeUpdateCd = Countdown(60);
 
   // Returns true if the function should be called again or false if other
   // controller handling can be done.
   bool readGpsDataFromGpsd();
+  // If the time is totally wrong (e.g. year 2000 after system reset because we do not have a RTC)
+  // we set it with the roughly valid time from the GPS. For some reason, NTP might only work
+  // if the time difference between sys time and current time is not too large
+  void overwriteTimeIfNotSane(timeval time, bool validFix);
 };
 
 #endif /* MISSION_DEVICES_GPSHYPERIONHANDLER_H_ */

linux/fsfwconfig/events/translateEvents.cpp

@@ -1,7 +1,7 @@
 /**
- * @brief    Auto-generated event translation file. Contains 245 translations.
+ * @brief    Auto-generated event translation file. Contains 248 translations.
  * @details
- * Generated on: 2023-02-03 10:52:53
+ * Generated on: 2023-02-08 14:09:40
  */
 #include "translateEvents.h"
 
@@ -200,6 +200,7 @@ const char *POWER_STATE_MACHINE_TIMEOUT_STRING = "POWER_STATE_MACHINE_TIMEOUT";
 const char *SIDE_SWITCH_TRANSITION_NOT_ALLOWED_STRING = "SIDE_SWITCH_TRANSITION_NOT_ALLOWED";
 const char *CHILDREN_LOST_MODE_STRING = "CHILDREN_LOST_MODE";
 const char *GPS_FIX_CHANGE_STRING = "GPS_FIX_CHANGE";
+const char *CANT_GET_FIX_STRING = "CANT_GET_FIX";
 const char *P60_BOOT_COUNT_STRING = "P60_BOOT_COUNT";
 const char *BATT_MODE_STRING = "BATT_MODE";
 const char *BATT_MODE_CHANGED_STRING = "BATT_MODE_CHANGED";
@@ -245,6 +246,8 @@ const char *REBOOT_SW_STRING = "REBOOT_SW";
 const char *REBOOT_MECHANISM_TRIGGERED_STRING = "REBOOT_MECHANISM_TRIGGERED";
 const char *REBOOT_HW_STRING = "REBOOT_HW";
 const char *NO_SD_CARD_ACTIVE_STRING = "NO_SD_CARD_ACTIVE";
+const char *VERSION_INFO_STRING = "VERSION_INFO";
+const char *CURRENT_IMAGE_INFO_STRING = "CURRENT_IMAGE_INFO";
 
 const char *translateEvents(Event event) {
   switch ((event & 0xFFFF)) {
@@ -638,6 +641,8 @@ const char *translateEvents(Event event) {
       return CHILDREN_LOST_MODE_STRING;
     case (13100):
       return GPS_FIX_CHANGE_STRING;
+    case (13101):
+      return CANT_GET_FIX_STRING;
     case (13200):
       return P60_BOOT_COUNT_STRING;
     case (13201):
@@ -728,6 +733,10 @@ const char *translateEvents(Event event) {
       return REBOOT_HW_STRING;
     case (14004):
       return NO_SD_CARD_ACTIVE_STRING;
+    case (14005):
+      return VERSION_INFO_STRING;
+    case (14006):
+      return CURRENT_IMAGE_INFO_STRING;
     default:
       return "UNKNOWN_EVENT";
   }

linux/fsfwconfig/objects/translateObjects.cpp

@@ -2,7 +2,7 @@
  * @brief  Auto-generated object translation file.
  * @details
  * Contains 152 translations.
- * Generated on: 2023-02-03 10:52:53
+ * Generated on: 2023-02-08 14:09:40
  */
 #include "translateObjects.h"
 

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -15,38 +15,17 @@
 #define RPI_TEST_GPS_HANDLER 0
 #endif
 
-ReturnValue_t pst::pstSpiRw(FixedTimeslotTaskIF *thisSequence) {
+ReturnValue_t pst::pstSpiAndSyrlinks(FixedTimeslotTaskIF *thisSequence) {
   uint32_t length = thisSequence->getPeriodMs();
-  static_cast<void>(length);
-  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.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RW2, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RW3, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RW4, length * 0.2, DeviceHandlerIF::SEND_WRITE);
+#if OBSW_ADD_SYRLINKS == 1
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
+#endif
 
-  thisSequence->addSlot(objects::RW1, length * 0.8, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RW2, length * 0.8, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RW3, length * 0.8, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RW4, length * 0.8, DeviceHandlerIF::GET_WRITE);
-
-  thisSequence->addSlot(objects::RW1, length * 0.8, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RW2, length * 0.8, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RW3, length * 0.8, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RW4, length * 0.8, DeviceHandlerIF::SEND_READ);
-
-  thisSequence->addSlot(objects::RW1, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RW2, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RW3, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::RW4, length * 0.8, DeviceHandlerIF::GET_READ);
-  return thisSequence->checkSequence();
-}
-
-ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
-  uint32_t length = thisSequence->getPeriodMs();
   static_cast<void>(length);
 #if OBSW_ADD_PL_PCDU == 1
   thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
@@ -56,271 +35,6 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 #endif
 
-#if OBSW_ADD_SUN_SENSORS == 1
-
-  bool addSus0 = true;
-  bool addSus1 = true;
-  bool addSus2 = true;
-  bool addSus3 = true;
-  bool addSus4 = true;
-  bool addSus5 = true;
-  bool addSus6 = true;
-  bool addSus7 = true;
-  bool addSus8 = true;
-  bool addSus9 = true;
-  bool addSus10 = true;
-  bool addSus11 = true;
-
-  if (addSus0) {
-    /* Write setup */
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.4,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.4,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.4,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.4,
-                          DeviceHandlerIF::GET_READ);
-  }
-  if (addSus1) {
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.4,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.4,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.4,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.4,
-                          DeviceHandlerIF::GET_READ);
-  }
-  if (addSus2) {
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.4,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.4,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.4,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.4,
-                          DeviceHandlerIF::GET_READ);
-  }
-  if (addSus3) {
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.4,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.4,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.4,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.4,
-                          DeviceHandlerIF::GET_READ);
-  }
-  if (addSus4) {
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.4,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.4,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.4,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.4,
-                          DeviceHandlerIF::GET_READ);
-  }
-  if (addSus5) {
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.4,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.4,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.4,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.4,
-                          DeviceHandlerIF::GET_READ);
-  }
-
-  if (addSus6) {
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.4,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.4,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.4,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.4,
-                          DeviceHandlerIF::GET_READ);
-  }
-
-  if (addSus7) {
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.4,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.4,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.4,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.4,
-                          DeviceHandlerIF::GET_READ);
-  }
-
-  if (addSus8) {
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.4,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.4,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.4,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.4,
-                          DeviceHandlerIF::GET_READ);
-  }
-
-  if (addSus9) {
-    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0,
-                          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 * 0.4,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.4,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.4,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.4,
-                          DeviceHandlerIF::GET_READ);
-  }
-
-  if (addSus10) {
-    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0,
-                          DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.4,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.4,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.4,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.4,
-                          DeviceHandlerIF::GET_READ);
-  }
-
-  if (addSus11) {
-    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0,
-                          DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.4,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.4,
-                          DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.4,
-                          DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.4,
-                          DeviceHandlerIF::GET_READ);
-  }
-#endif /* OBSW_ADD_SUN_SENSORS == 1 */
-
 #if OBSW_ADD_RAD_SENSORS == 1
   /* Radiation sensor */
   thisSequence->addSlot(objects::RAD_SENSOR, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
@@ -330,74 +44,6 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::RAD_SENSOR, length * 0.8, DeviceHandlerIF::GET_READ);
 #endif
 
-#if OBSW_ADD_ACS_BOARD == 1
-  bool enableAside = true;
-  bool enableBside = true;
-  if (enableAside) {
-    // A side
-    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.25,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
-  }
-
-  if (enableBside) {
-    // B side
-    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.25,
-                          DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
-
-    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0,
-                          DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE);
-    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
-    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
-  }
-#endif /* OBSW_ADD_ACS_BOARD == 1 */
-
   return thisSequence->checkSequence();
 }
 
@@ -407,23 +53,6 @@ ReturnValue_t pst::pstI2c(FixedTimeslotTaskIF *thisSequence) {
   // Length of a communication cycle
   uint32_t length = thisSequence->getPeriodMs();
   static_cast<void>(length);
-#if OBSW_ADD_MGT == 1
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
-#endif
 #if OBSW_ADD_BPX_BATTERY_HANDLER == 1
   thisSequence->addSlot(objects::BPX_BATT_HANDLER, length * 0.2,
                         DeviceHandlerIF::PERFORM_OPERATION);
@@ -481,29 +110,6 @@ ReturnValue_t pst::pstI2c(FixedTimeslotTaskIF *thisSequence) {
   return thisSequence->checkSequence();
 }
 
-ReturnValue_t pst::pstUart(FixedTimeslotTaskIF *thisSequence) {
-  // Length of a communication cycle
-  uint32_t length = thisSequence->getPeriodMs();
-  static_cast<void>(length);
-
-#if OBSW_ADD_SYRLINKS == 1
-  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SYRLINKS_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
-#endif
-
-#if OBSW_ADD_STAR_TRACKER == 1
-  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::STAR_TRACKER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::STAR_TRACKER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::STAR_TRACKER, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::STAR_TRACKER, length * 0.8, DeviceHandlerIF::GET_READ);
-#endif
-  return thisSequence->checkSequence();
-}
-
 ReturnValue_t pst::pstGompaceCan(FixedTimeslotTaskIF *thisSequence) {
   uint32_t length = thisSequence->getPeriodMs();
   // PCDU handlers receives two messages and both must be handled
@@ -576,3 +182,422 @@ ReturnValue_t pst::pstTest(FixedTimeslotTaskIF *thisSequence) {
   }
   return returnvalue::OK;
 }
+
+ReturnValue_t pst::pstAcs(FixedTimeslotTaskIF *thisSequence) {
+  /* Length of a communication cycle */
+  uint32_t length = thisSequence->getPeriodMs();
+#if OBSW_ADD_ACS_BOARD == 1
+  bool enableAside = true;
+  bool enableBside = true;
+  if (enableAside) {
+    // A side
+    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
+  }
+
+  if (enableBside) {
+    // B side
+    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.0625,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
+  }
+#endif /* OBSW_ADD_ACS_BOARD == 1 */
+  // SUS: 16 ms
+#if OBSW_ADD_SUN_SENSORS == 1
+
+  bool addSus0 = true;
+  bool addSus1 = true;
+  bool addSus2 = true;
+  bool addSus3 = true;
+  bool addSus4 = true;
+  bool addSus5 = true;
+  bool addSus6 = true;
+  bool addSus7 = true;
+  bool addSus8 = true;
+  bool addSus9 = true;
+  bool addSus10 = true;
+  bool addSus11 = true;
+
+  if (addSus0) {
+    /* Write setup */
+    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.0325,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.0325,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.0325,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0.0325,
+                          DeviceHandlerIF::GET_READ);
+  }
+  if (addSus1) {
+    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.0325,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.0325,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.0325,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0.0325,
+                          DeviceHandlerIF::GET_READ);
+  }
+  if (addSus2) {
+    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.0325,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.0325,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.0325,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB, length * 0.0325,
+                          DeviceHandlerIF::GET_READ);
+  }
+  if (addSus3) {
+    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.0325,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.0325,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.0325,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF, length * 0.0325,
+                          DeviceHandlerIF::GET_READ);
+  }
+  if (addSus4) {
+    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.0325,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.0325,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.0325,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, length * 0.0325,
+                          DeviceHandlerIF::GET_READ);
+  }
+  if (addSus5) {
+    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.0325,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.0325,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.0325,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, length * 0.0325,
+                          DeviceHandlerIF::GET_READ);
+  }
+
+  if (addSus6) {
+    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.0325,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.0325,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.0325,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF, length * 0.0325,
+                          DeviceHandlerIF::GET_READ);
+  }
+
+  if (addSus7) {
+    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.0325,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.0325,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.0325,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB, length * 0.0325,
+                          DeviceHandlerIF::GET_READ);
+  }
+
+  if (addSus8) {
+    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.0325,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.0325,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.0325,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB, length * 0.0325,
+                          DeviceHandlerIF::GET_READ);
+  }
+
+  if (addSus9) {
+    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0,
+                          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 * 0.0325,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.0325,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.0325,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF, length * 0.0325,
+                          DeviceHandlerIF::GET_READ);
+  }
+
+  if (addSus10) {
+    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0,
+                          DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.0325,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.0325,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.0325,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, length * 0.0325,
+                          DeviceHandlerIF::GET_READ);
+  }
+
+  if (addSus11) {
+    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0,
+                          DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0,
+                          DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.0325,
+                          DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.0325,
+                          DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.0325,
+                          DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, length * 0.0325,
+                          DeviceHandlerIF::GET_READ);
+  }
+#endif /* OBSW_ADD_SUN_SENSORS == 1 */
+
+#if OBSW_ADD_STAR_TRACKER == 1
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::GET_READ);
+#endif
+
+#if OBSW_ADD_MGT == 1
+  // This is the MTM measurement cycle
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.0625, DeviceHandlerIF::GET_READ);
+#endif
+
+  thisSequence->addSlot(objects::ACS_CONTROLLER, length * 0.1, 0);
+
+#if OBSW_ADD_MGT == 1
+  // This is the torquing cycle.
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.1125, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.1125, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.1125, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.1125, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.1125, DeviceHandlerIF::GET_READ);
+#endif
+
+#if OBSW_ADD_RW == 1
+  thisSequence->addSlot(objects::RW1, length * 0.1125, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::RW2, length * 0.1125, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::RW3, length * 0.1125, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::RW4, length * 0.1125, DeviceHandlerIF::PERFORM_OPERATION);
+
+  thisSequence->addSlot(objects::RW1, length * 0.1125, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::RW2, length * 0.1125, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::RW3, length * 0.1125, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::RW4, length * 0.1125, DeviceHandlerIF::SEND_WRITE);
+
+  thisSequence->addSlot(objects::RW1, length * 0.1125, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::RW2, length * 0.1125, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::RW3, length * 0.1125, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::RW4, length * 0.1125, DeviceHandlerIF::GET_WRITE);
+
+  thisSequence->addSlot(objects::RW1, length * 0.1125, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::RW2, length * 0.1125, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::RW3, length * 0.1125, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::RW4, length * 0.1125, DeviceHandlerIF::SEND_READ);
+
+  thisSequence->addSlot(objects::RW1, length * 0.1125, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::RW2, length * 0.1125, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::RW3, length * 0.1125, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::RW4, length * 0.1125, DeviceHandlerIF::GET_READ);
+#endif
+  return returnvalue::OK;
+}

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.h

@@ -39,11 +39,9 @@ namespace pst {
  */
 ReturnValue_t pstGompaceCan(FixedTimeslotTaskIF* thisSequence);
 
-ReturnValue_t pstUart(FixedTimeslotTaskIF* thisSequence);
+ReturnValue_t pstSpiAndSyrlinks(FixedTimeslotTaskIF* thisSequence);
 
-ReturnValue_t pstSpi(FixedTimeslotTaskIF* thisSequence);
-
-ReturnValue_t pstSpiRw(FixedTimeslotTaskIF* thisSequence);
+ReturnValue_t pstAcs(FixedTimeslotTaskIF* thisSequence);
 
 ReturnValue_t pstI2c(FixedTimeslotTaskIF* thisSequence);