Merge pull request 'Rework SUS polling' (#408) from rework_sus_polling into develop

Reviewed-on: #408

CHANGELOG.md

@@ -19,6 +19,7 @@ will consitute of a breaking change warranting a new major release:
 ## Changed
 
 - Move ACS board polling to separate worker thread.
+- Move SUS board polling to separate worker thread.
 
 ## Fixed
 

bsp_q7s/core/scheduling.cpp

@@ -220,6 +220,15 @@ void scheduling::initTasks() {
   }
 #endif
 
+#if OBSW_ADD_SUN_SENSORS == 1
+  PeriodicTaskIF* susPolling = factory->createPeriodicTask(
+      "SUS_POLLING_TASK", 85, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
+  result = susPolling->addComponent(objects::SUS_POLLING_TASK);
+  if (result != returnvalue::OK) {
+    scheduling::printAddObjectError("SUS_POLLING_TASK", objects::SUS_POLLING_TASK);
+  }
+#endif
+
   PeriodicTaskIF* acsSysTask = factory->createPeriodicTask(
       "ACS_SYS_TASK", 55, PeriodicTaskIF::MINIMUM_STACK_SIZE * 2, 0.4, missedDeadlineFunc);
   static_cast<void>(acsSysTask);
@@ -366,6 +375,9 @@ void scheduling::initTasks() {
 #if OBSW_ADD_MGT == 1
   imtqPolling->startTask();
 #endif
+#if OBSW_ADD_SUN_SENSORS == 1
+  susPolling->startTask();
+#endif
 
   taskStarter(pstTasks, "PST task vector");
   taskStarter(pusTasks, "PUS task vector");

bsp_q7s/memory/LocalParameterHandler.h

@@ -19,8 +19,8 @@ class LocalParameterHandler : public NVMParameterBase {
    * @brief	Constructor
    *
    * @param sdRelativeName	Absolute name of json file relative to mount
-   * 												directory	of SD card.
+   * 												directory
-   * E.g. conf/example.json
+   * of SD card. E.g. conf/example.json
    * @param sdcMan	Pointer to SD card manager
    */
   LocalParameterHandler(std::string sdRelativeName, SdCardMountedIF* sdcMan);

common/config/eive/objects.h

@@ -126,6 +126,7 @@ enum commonObjects : uint32_t {
   ACS_BOARD_POLLING_TASK = 0x49060004,
   RW_POLLING_TASK = 0x49060005,
   SPI_RTD_COM_IF = 0x49060006,
+  SUS_POLLING_TASK = 0x49060007,
 
   // 0x60 for other stuff
   HEATER_0_PLOC_PROC_BRD = 0x60000000,

dummies/CoreControllerDummy.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include <fsfw/controller/ExtendedControllerBase.h>
-#include <mission/devices/devicedefinitions/SusDefinitions.h>
+#include <mission/devices/devicedefinitions/susMax1227Helpers.h>
 
 class CoreControllerDummy : public ExtendedControllerBase {
  public:

dummies/SusDummy.cpp

@@ -35,8 +35,9 @@ uint32_t SusDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return
 
 ReturnValue_t SusDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                 LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(SUS::SusPoolIds::TEMPERATURE_C, new PoolEntry<float>({0}, 1, true));
+  localDataPoolMap.emplace(susMax1227::SusPoolIds::TEMPERATURE_C,
-  localDataPoolMap.emplace(SUS::SusPoolIds::CHANNEL_VEC,
+                           new PoolEntry<float>({0}, 1, true));
+  localDataPoolMap.emplace(susMax1227::SusPoolIds::CHANNEL_VEC,
                            new PoolEntry<uint16_t>({2603, 781, 2760, 2048, 4056, 0}, true));
 
   return returnvalue::OK;

dummies/SusDummy.h

@@ -2,8 +2,7 @@
 #define DUMMIES_SUSDUMMY_H_
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
-
+#include <mission/devices/devicedefinitions/susMax1227Helpers.h>
-#include "mission/devices/devicedefinitions/SusDefinitions.h"
 
 class SusDummy : public DeviceHandlerBase {
  public:
@@ -17,7 +16,7 @@ class SusDummy : public DeviceHandlerBase {
   virtual ~SusDummy();
 
  protected:
-  SUS::SusDataset susSet;
+  susMax1227::SusDataset susSet;
   void doStartUp() override;
   void doShutDown() override;
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;

linux/ObjectFactory.cpp

@@ -10,8 +10,10 @@
 #include <fsfw_hal/linux/spi/SpiCookie.h>
 #include <linux/callbacks/gpioCallbacks.h>
 #include <linux/devices/Max31865RtdPolling.h>
+#include <linux/devices/SusPolling.h>
 #include <mission/controller/AcsController.h>
 #include <mission/core/GenericFactory.h>
+#include <mission/devices/LegacySusHandler.h>
 #include <mission/devices/Max31865EiveHandler.h>
 #include <mission/devices/ScexDeviceHandler.h>
 #include <mission/devices/SusHandler.h>
@@ -33,6 +35,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
                                               PowerSwitchIF& pwrSwitcher, std::string spiDev,
                                               bool swap0And6) {
   using namespace gpio;
+  new SusPolling(objects::SUS_POLLING_TASK, *spiComIF, *gpioComIF);
   GpioCookie* gpioCookieSus = new GpioCookie();
   GpioCallback* susgpio = nullptr;
 
@@ -78,99 +81,100 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
 #if OBSW_ADD_SUN_SENSORS == 1
   SusFdir* fdir = nullptr;
   std::array<SusHandler*, 12> susHandlers = {};
-  SpiCookie* spiCookie = new SpiCookie(addresses::SUS_0, gpioIds::CS_SUS_0, SUS::MAX_CMD_SIZE,
+  SpiCookie* spiCookie =
+      new SpiCookie(addresses::SUS_0, gpioIds::CS_SUS_0, susMax1227::MAX_CMD_SIZE,
                     spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[0] =
-      new SusHandler(objects::SUS_0_N_LOC_XFYFZM_PT_XF, 0, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_0_N_LOC_XFYFZM_PT_XF, 0, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
   susHandlers[0]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[1] =
-      new SusHandler(objects::SUS_1_N_LOC_XBYFZM_PT_XB, 1, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_1_N_LOC_XBYFZM_PT_XB, 1, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_1_N_LOC_XBYFZM_PT_XB);
   susHandlers[1]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[2] =
-      new SusHandler(objects::SUS_2_N_LOC_XFYBZB_PT_YB, 2, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_2_N_LOC_XFYBZB_PT_YB, 2, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_2_N_LOC_XFYBZB_PT_YB);
   susHandlers[2]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[3] =
-      new SusHandler(objects::SUS_3_N_LOC_XFYBZF_PT_YF, 3, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_3_N_LOC_XFYBZF_PT_YF, 3, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_3_N_LOC_XFYBZF_PT_YF);
   susHandlers[3]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[4] =
-      new SusHandler(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, 4, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, 4, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_4_N_LOC_XMYFZF_PT_ZF);
   susHandlers[4]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[5] =
-      new SusHandler(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, 5, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, 5, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_5_N_LOC_XFYMZB_PT_ZB);
   susHandlers[5]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[6] =
-      new SusHandler(objects::SUS_6_R_LOC_XFYBZM_PT_XF, 6, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_6_R_LOC_XFYBZM_PT_XF, 6, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_6_R_LOC_XFYBZM_PT_XF);
   susHandlers[6]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[7] =
-      new SusHandler(objects::SUS_7_R_LOC_XBYBZM_PT_XB, 7, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_7_R_LOC_XBYBZM_PT_XB, 7, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_7_R_LOC_XBYBZM_PT_XB);
   susHandlers[7]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[8] =
-      new SusHandler(objects::SUS_8_R_LOC_XBYBZB_PT_YB, 8, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_8_R_LOC_XBYBZB_PT_YB, 8, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_8_R_LOC_XBYBZB_PT_YB);
   susHandlers[8]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[9] =
-      new SusHandler(objects::SUS_9_R_LOC_XBYBZB_PT_YF, 9, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_9_R_LOC_XBYBZB_PT_YF, 9, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_9_R_LOC_XBYBZB_PT_YF);
   susHandlers[9]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[10] =
-      new SusHandler(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, 10, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, 10, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_10_N_LOC_XMYBZF_PT_ZF);
   susHandlers[10]->setCustomFdir(fdir);
 
-  spiCookie = new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, susMax1227::MAX_CMD_SIZE,
                             spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
   spiCookie->setMutexParams(MutexIF::TimeoutType::WAITING, spi::SUS_CS_TIMEOUT);
   susHandlers[11] =
-      new SusHandler(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, 11, objects::SPI_MAIN_COM_IF, spiCookie);
+      new SusHandler(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, 11, objects::SUS_POLLING_TASK, spiCookie);
   fdir = new SusFdir(objects::SUS_11_R_LOC_XBYMZB_PT_ZB);
   susHandlers[11]->setCustomFdir(fdir);
 

linux/devices/AcsBoardPolling.h

@@ -24,7 +24,6 @@ class AcsBoardPolling : public SystemObject,
   MutexIF* ipcLock;
   SemaphoreIF* semaphore;
   std::array<uint8_t, 32> cmdBuf;
-  std::array<uint8_t, 32> replyBuf;
 
   struct DevBase {
     SpiCookie* cookie = nullptr;

linux/devices/CMakeLists.txt

@@ -7,6 +7,7 @@ target_sources(
   PRIVATE Max31865RtdPolling.cpp
           ScexUartReader.cpp
           ImtqPollingTask.cpp
+          SusPolling.cpp
           ScexDleParser.cpp
           ScexHelper.cpp
           RwPollingTask.cpp

linux/devices/SusPolling.cpp

@@ -0,0 +1,215 @@
+#include "SusPolling.h"
+
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw_hal/linux/spi/SpiCookie.h>
+#include <mission/controller/acs/AcsParameters.h>
+#include <mission/devices/max1227.h>
+#include <unistd.h>
+
+#include "mission/devices/devicedefinitions/susMax1227Helpers.h"
+
+using namespace returnvalue;
+
+SusPolling::SusPolling(object_id_t objectId, SpiComIF& spiComIF, GpioIF& gpioIF)
+    : SystemObject(objectId), spiComIF(spiComIF), gpioIF(gpioIF) {
+  semaphore = SemaphoreFactory::instance()->createBinarySemaphore();
+  semaphore->acquire();
+  ipcLock = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t SusPolling::performOperation(uint8_t operationCode) {
+  while (true) {
+    ipcLock->lockMutex();
+    state = InternalState::IDLE;
+    ipcLock->unlockMutex();
+    semaphore->acquire();
+    // Give SUS handlers a chance to submit all requests.
+    TaskFactory::delayTask(2);
+    handleSusPolling();
+    // Protection against tardy tasks unlocking the thread again immediately.
+    TaskFactory::delayTask(20);
+  }
+  return OK;
+}
+
+ReturnValue_t SusPolling::initialize() { return OK; }
+
+ReturnValue_t SusPolling::initializeInterface(CookieIF* cookie) {
+  auto* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  if (spiCookie == nullptr) {
+    return FAILED;
+  }
+  int susIdx = addressToIndex(spiCookie->getSpiAddress());
+  if (susIdx < 0) {
+    return FAILED;
+  }
+  susDevs[susIdx].cookie = spiCookie;
+  return spiComIF.initializeInterface(cookie);
+}
+
+ReturnValue_t SusPolling::sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) {
+  auto* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  if (spiCookie == nullptr) {
+    return FAILED;
+  }
+  int susIdx = addressToIndex(spiCookie->getSpiAddress());
+  if (susIdx < 0) {
+    return FAILED;
+  }
+  if (sendLen != sizeof(acs::SusRequest)) {
+    return FAILED;
+  }
+  const auto* susReq = reinterpret_cast<const acs::SusRequest*>(sendData);
+  MutexGuard mg(ipcLock);
+  if (susDevs[susIdx].mode != susReq->mode) {
+    if (susReq->mode == acs::SimpleSensorMode::NORMAL) {
+      susDevs[susIdx].performStartup = true;
+    } else {
+      susDevs[susIdx].ownReply.cfgWasSet = false;
+      susDevs[susIdx].ownReply.dataWasSet = false;
+    }
+    susDevs[susIdx].mode = susReq->mode;
+  }
+  if (state == InternalState::IDLE) {
+    state = InternalState::BUSY;
+    semaphore->release();
+  }
+  return OK;
+}
+
+ReturnValue_t SusPolling::getSendSuccess(CookieIF* cookie) { return OK; }
+
+ReturnValue_t SusPolling::requestReceiveMessage(CookieIF* cookie, size_t requestLen) { return OK; }
+
+ReturnValue_t SusPolling::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
+  auto* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  if (spiCookie == nullptr) {
+    return FAILED;
+  }
+  int susIdx = addressToIndex(spiCookie->getSpiAddress());
+  if (susIdx < 0) {
+    return FAILED;
+  }
+  MutexGuard mg(ipcLock);
+  std::memcpy(&susDevs[susIdx].readerReply, &susDevs[susIdx].ownReply, sizeof(acs::SusReply));
+  *buffer = reinterpret_cast<uint8_t*>(&susDevs[susIdx].readerReply);
+  *size = sizeof(acs::SusReply);
+  return OK;
+}
+
+ReturnValue_t SusPolling::handleSusPolling() {
+  ReturnValue_t result;
+  acs::SimpleSensorMode modes[12];
+  bool performStartups[12]{};
+  bool cfgsWereSet[12]{};
+  uint8_t idx = 0;
+  {
+    MutexGuard mg(ipcLock);
+    for (idx = 0; idx < 12; idx++) {
+      modes[idx] = susDevs[idx].mode;
+      performStartups[idx] = susDevs[idx].performStartup;
+    }
+  }
+  for (idx = 0; idx < 12; idx++) {
+    if (modes[idx] == acs::SimpleSensorMode::NORMAL) {
+      if (performStartups[idx]) {
+        // Startup handling.
+        cmdBuf[0] = susMax1227::SETUP_INT_CLOKED;
+        result = spiComIF.sendMessage(susDevs[idx].cookie, cmdBuf.data(), 1);
+        if (result != OK) {
+          susDevs[idx].replyResult = result;
+          continue;
+        }
+        MutexGuard mg(ipcLock);
+        susDevs[idx].ownReply.cfgWasSet = true;
+        cfgsWereSet[idx] = true;
+        susDevs[idx].performStartup = true;
+      }
+    }
+  }
+  for (idx = 0; idx < 12; idx++) {
+    if (modes[idx] == acs::SimpleSensorMode::NORMAL and cfgsWereSet[idx]) {
+      // Regular sensor polling.
+      cmdBuf[0] = max1227::buildResetByte(true);
+      cmdBuf[1] = susMax1227::CONVERSION;
+      result = spiComIF.sendMessage(susDevs[idx].cookie, cmdBuf.data(), 2);
+      if (result != OK) {
+        susDevs[idx].replyResult = result;
+        continue;
+      }
+    }
+  }
+
+  // Internal conversion time is 3.5 us
+  usleep(4);
+
+  for (idx = 0; idx < 12; idx++) {
+    if (modes[idx] == acs::SimpleSensorMode::NORMAL and cfgsWereSet[idx]) {
+      std::memset(cmdBuf.data(), 0, susMax1227::SIZE_READ_INT_CONVERSIONS);
+      result = spiComIF.sendMessage(susDevs[idx].cookie, cmdBuf.data(),
+                                    susMax1227::SIZE_READ_INT_CONVERSIONS);
+      if (result != OK) {
+        susDevs[idx].replyResult = result;
+        continue;
+      }
+      result = spiComIF.readReceivedMessage(susDevs[idx].cookie, &rawReply, &dummy);
+      if (result != OK) {
+        susDevs[idx].replyResult = result;
+        continue;
+      }
+      MutexGuard mg(ipcLock);
+      susDevs[idx].ownReply.tempRaw = ((rawReply[0] & 0x0f) << 8) | rawReply[1];
+      for (unsigned chIdx = 0; chIdx < 6; chIdx++) {
+        susDevs[idx].ownReply.channelsRaw[chIdx] =
+            (rawReply[chIdx * 2 + 2] << 8) | rawReply[chIdx * 2 + 3];
+      }
+      susDevs[idx].ownReply.dataWasSet = true;
+    }
+  }
+  return OK;
+}
+
+int SusPolling::addressToIndex(address_t addr) {
+  switch (addr) {
+    case (addresses::SUS_0):
+      return 0;
+      break;
+    case (addresses::SUS_1):
+      return 1;
+      break;
+    case (addresses::SUS_2):
+      return 2;
+      break;
+    case (addresses::SUS_3):
+      return 3;
+      break;
+    case (addresses::SUS_4):
+      return 4;
+      break;
+    case (addresses::SUS_5):
+      return 5;
+      break;
+    case (addresses::SUS_6):
+      return 6;
+      break;
+    case (addresses::SUS_7):
+      return 7;
+      break;
+    case (addresses::SUS_8):
+      return 8;
+      break;
+    case (addresses::SUS_9):
+      return 9;
+      break;
+    case (addresses::SUS_10):
+      return 10;
+      break;
+    case (addresses::SUS_11):
+      return 11;
+      break;
+    default: {
+      return -1;
+    }
+  }
+}

linux/devices/SusPolling.h

@@ -0,0 +1,52 @@
+#ifndef LINUX_DEVICES_SUSPOLLING_H_
+#define LINUX_DEVICES_SUSPOLLING_H_
+
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+#include <fsfw/tasks/SemaphoreIF.h>
+#include <fsfw_hal/linux/spi/SpiComIF.h>
+
+#include "devices/addresses.h"
+#include "mission/devices/devicedefinitions/acsPolling.h"
+
+class SusPolling : public SystemObject, public ExecutableObjectIF, public DeviceCommunicationIF {
+ public:
+  SusPolling(object_id_t objectId, SpiComIF& spiComIF, GpioIF& gpioIF);
+
+  ReturnValue_t performOperation(uint8_t operationCode) override;
+  ReturnValue_t initialize() override;
+
+ private:
+  enum class InternalState { IDLE, BUSY } state = InternalState::IDLE;
+
+  struct SusDev {
+    SpiCookie* cookie = nullptr;
+    bool performStartup = false;
+    acs::SimpleSensorMode mode = acs::SimpleSensorMode::OFF;
+    ReturnValue_t replyResult = returnvalue::OK;
+    acs::SusReply ownReply{};
+    acs::SusReply readerReply{};
+  };
+
+  MutexIF* ipcLock;
+  SemaphoreIF* semaphore;
+  uint8_t* rawReply = nullptr;
+  size_t dummy = 0;
+  SpiComIF& spiComIF;
+  GpioIF& gpioIF;
+
+  std::array<SusDev, 12> susDevs;
+  std::array<uint8_t, 32> cmdBuf;
+
+  ReturnValue_t initializeInterface(CookieIF* cookie) override;
+  ReturnValue_t sendMessage(CookieIF* cookie, const uint8_t* sendData, size_t sendLen) override;
+  ReturnValue_t getSendSuccess(CookieIF* cookie) override;
+  ReturnValue_t requestReceiveMessage(CookieIF* cookie, size_t requestLen) override;
+  ReturnValue_t readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) override;
+
+  ReturnValue_t handleSusPolling();
+  static int addressToIndex(address_t addr);
+};
+
+#endif /* LINUX_DEVICES_SUSPOLLING_H_ */

linux/ipcore/PdecHandler.h

@@ -105,8 +105,7 @@ class PdecHandler : public SystemObject,
   //! [EXPORT] : [COMMENT] Failed to pull PDEC reset to low
   static constexpr Event PDEC_RESET_FAILED = event::makeEvent(SUBSYSTEM_ID, 10, severity::HIGH);
   //! [EXPORT] : [COMMENT] Failed to open the IRQ uio file
-  static constexpr Event OPEN_IRQ_FILE_FAILED =
+  static constexpr Event OPEN_IRQ_FILE_FAILED = event::makeEvent(SUBSYSTEM_ID, 11, severity::HIGH);
-      event::makeEvent(SUBSYSTEM_ID, 11, severity::HIGH);
 
  private:
   static const uint8_t INTERFACE_ID = CLASS_ID::PDEC_HANDLER;

mission/controller/AcsController.h

@@ -8,9 +8,9 @@
 #include <fsfw/parameters/ReceivesParameterMessagesIF.h>
 #include <fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h>
 #include <fsfw_hal/devicehandlers/MgmRM3100Handler.h>
-#include <mission/devices/devicedefinitions/SusDefinitions.h>
 #include <mission/devices/devicedefinitions/imtqHelpers.h>
 #include <mission/devices/devicedefinitions/rwHelpers.h>
+#include <mission/devices/devicedefinitions/susMax1227Helpers.h>
 #include <mission/trace.h>
 
 #include "acs/ActuatorCmd.h"

mission/controller/ThermalController.cpp

@@ -474,8 +474,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg0(&susSet0, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg0.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.value = susSet0.temperatureCelcius.value;
+      susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.value = susSet0.tempC.value;
-      susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.setValid(susSet0.temperatureCelcius.isValid());
+      susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.setValid(susSet0.tempC.isValid());
       if (not susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.isValid()) {
         susTemperatures.sus_0_n_loc_xfyfzm_pt_xf.value = INVALID_TEMPERATURE;
       }
@@ -485,8 +485,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg1(&susSet1, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg1.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_6_r_loc_xfybzm_pt_xf.value = susSet1.temperatureCelcius.value;
+      susTemperatures.sus_6_r_loc_xfybzm_pt_xf.value = susSet1.tempC.value;
-      susTemperatures.sus_6_r_loc_xfybzm_pt_xf.setValid(susSet1.temperatureCelcius.isValid());
+      susTemperatures.sus_6_r_loc_xfybzm_pt_xf.setValid(susSet1.tempC.isValid());
       if (not susTemperatures.sus_6_r_loc_xfybzm_pt_xf.isValid()) {
         susTemperatures.sus_6_r_loc_xfybzm_pt_xf.value = INVALID_TEMPERATURE;
       }
@@ -496,8 +496,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg2(&susSet2, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg2.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.value = susSet2.temperatureCelcius.value;
+      susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.value = susSet2.tempC.value;
-      susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.setValid(susSet2.temperatureCelcius.isValid());
+      susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.setValid(susSet2.tempC.isValid());
       if (not susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.isValid()) {
         susTemperatures.sus_1_n_loc_xbyfzm_pt_xb.value = INVALID_TEMPERATURE;
       }
@@ -507,8 +507,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg3(&susSet3, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg3.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_7_r_loc_xbybzm_pt_xb.value = susSet3.temperatureCelcius.value;
+      susTemperatures.sus_7_r_loc_xbybzm_pt_xb.value = susSet3.tempC.value;
-      susTemperatures.sus_7_r_loc_xbybzm_pt_xb.setValid(susSet3.temperatureCelcius.isValid());
+      susTemperatures.sus_7_r_loc_xbybzm_pt_xb.setValid(susSet3.tempC.isValid());
       if (not susTemperatures.sus_7_r_loc_xbybzm_pt_xb.isValid()) {
         susTemperatures.sus_7_r_loc_xbybzm_pt_xb.value = INVALID_TEMPERATURE;
       }
@@ -518,8 +518,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg4(&susSet4, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg4.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_2_n_loc_xfybzb_pt_yb.value = susSet4.temperatureCelcius.value;
+      susTemperatures.sus_2_n_loc_xfybzb_pt_yb.value = susSet4.tempC.value;
-      susTemperatures.sus_2_n_loc_xfybzb_pt_yb.setValid(susSet4.temperatureCelcius.isValid());
+      susTemperatures.sus_2_n_loc_xfybzb_pt_yb.setValid(susSet4.tempC.isValid());
       if (not susTemperatures.sus_2_n_loc_xfybzb_pt_yb.isValid()) {
         susTemperatures.sus_2_n_loc_xfybzb_pt_yb.value = INVALID_TEMPERATURE;
       }
@@ -529,8 +529,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg5(&susSet5, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg5.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_8_r_loc_xbybzb_pt_yb.value = susSet5.temperatureCelcius.value;
+      susTemperatures.sus_8_r_loc_xbybzb_pt_yb.value = susSet5.tempC.value;
-      susTemperatures.sus_8_r_loc_xbybzb_pt_yb.setValid(susSet5.temperatureCelcius.isValid());
+      susTemperatures.sus_8_r_loc_xbybzb_pt_yb.setValid(susSet5.tempC.isValid());
       if (not susTemperatures.sus_8_r_loc_xbybzb_pt_yb.isValid()) {
         susTemperatures.sus_8_r_loc_xbybzb_pt_yb.value = INVALID_TEMPERATURE;
       }
@@ -540,8 +540,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg6(&susSet6, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg6.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_3_n_loc_xfybzf_pt_yf.value = susSet6.temperatureCelcius.value;
+      susTemperatures.sus_3_n_loc_xfybzf_pt_yf.value = susSet6.tempC.value;
-      susTemperatures.sus_3_n_loc_xfybzf_pt_yf.setValid(susSet6.temperatureCelcius.isValid());
+      susTemperatures.sus_3_n_loc_xfybzf_pt_yf.setValid(susSet6.tempC.isValid());
       if (not susTemperatures.sus_3_n_loc_xfybzf_pt_yf.isValid()) {
         susTemperatures.sus_3_n_loc_xfybzf_pt_yf.value = INVALID_TEMPERATURE;
       }
@@ -551,8 +551,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg7(&susSet7, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg7.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_9_r_loc_xbybzb_pt_yf.value = susSet7.temperatureCelcius.value;
+      susTemperatures.sus_9_r_loc_xbybzb_pt_yf.value = susSet7.tempC.value;
-      susTemperatures.sus_9_r_loc_xbybzb_pt_yf.setValid(susSet7.temperatureCelcius.isValid());
+      susTemperatures.sus_9_r_loc_xbybzb_pt_yf.setValid(susSet7.tempC.isValid());
       if (not susTemperatures.sus_9_r_loc_xbybzb_pt_yf.isValid()) {
         susTemperatures.sus_9_r_loc_xbybzb_pt_yf.value = INVALID_TEMPERATURE;
       }
@@ -562,8 +562,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg8(&susSet8, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg8.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.value = susSet8.temperatureCelcius.value;
+      susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.value = susSet8.tempC.value;
-      susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.setValid(susSet8.temperatureCelcius.isValid());
+      susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.setValid(susSet8.tempC.isValid());
       if (not susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.isValid()) {
         susTemperatures.sus_4_n_loc_xmyfzf_pt_zf.value = INVALID_TEMPERATURE;
       }
@@ -573,8 +573,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg9(&susSet9, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg9.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_10_n_loc_xmybzf_pt_zf.value = susSet9.temperatureCelcius.value;
+      susTemperatures.sus_10_n_loc_xmybzf_pt_zf.value = susSet9.tempC.value;
-      susTemperatures.sus_10_n_loc_xmybzf_pt_zf.setValid(susSet9.temperatureCelcius.isValid());
+      susTemperatures.sus_10_n_loc_xmybzf_pt_zf.setValid(susSet9.tempC.isValid());
       if (not susTemperatures.sus_10_n_loc_xmybzf_pt_zf.isValid()) {
         susTemperatures.sus_10_n_loc_xmybzf_pt_zf.value = INVALID_TEMPERATURE;
       }
@@ -584,8 +584,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg10(&susSet10, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg10.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_5_n_loc_xfymzb_pt_zb.value = susSet10.temperatureCelcius.value;
+      susTemperatures.sus_5_n_loc_xfymzb_pt_zb.value = susSet10.tempC.value;
-      susTemperatures.sus_5_n_loc_xfymzb_pt_zb.setValid(susSet10.temperatureCelcius.isValid());
+      susTemperatures.sus_5_n_loc_xfymzb_pt_zb.setValid(susSet10.tempC.isValid());
       if (not susTemperatures.sus_5_n_loc_xfymzb_pt_zb.isValid()) {
         susTemperatures.sus_5_n_loc_xfymzb_pt_zb.value = INVALID_TEMPERATURE;
       }
@@ -595,8 +595,8 @@ void ThermalController::copySus() {
   {
     PoolReadGuard pg11(&susSet11, MutexIF::TimeoutType::WAITING, MUTEX_TIMEOUT);
     if (pg11.getReadResult() == returnvalue::OK) {
-      susTemperatures.sus_11_r_loc_xbymzb_pt_zb.value = susSet11.temperatureCelcius.value;
+      susTemperatures.sus_11_r_loc_xbymzb_pt_zb.value = susSet11.tempC.value;
-      susTemperatures.sus_11_r_loc_xbymzb_pt_zb.setValid(susSet11.temperatureCelcius.isValid());
+      susTemperatures.sus_11_r_loc_xbymzb_pt_zb.setValid(susSet11.tempC.isValid());
       if (not susTemperatures.sus_11_r_loc_xbymzb_pt_zb.isValid()) {
         susTemperatures.sus_11_r_loc_xbymzb_pt_zb.value = INVALID_TEMPERATURE;
       }

mission/controller/ThermalController.h

@@ -6,8 +6,8 @@
 #include <fsfw/timemanager/Countdown.h>
 #include <mission/controller/controllerdefinitions/ThermalControllerDefinitions.h>
 #include <mission/devices/devicedefinitions/Max31865Definitions.h>
-#include <mission/devices/devicedefinitions/SusDefinitions.h>
 #include <mission/devices/devicedefinitions/Tmp1075Definitions.h>
+#include <mission/devices/devicedefinitions/susMax1227Helpers.h>
 
 #include <list>
 
@@ -112,18 +112,18 @@ class ThermalController : public ExtendedControllerBase {
   TMP1075::Tmp1075Dataset tmp1075SetIfBoard;
 
   // SUS
-  SUS::SusDataset susSet0;
+  susMax1227::SusDataset susSet0;
-  SUS::SusDataset susSet1;
+  susMax1227::SusDataset susSet1;
-  SUS::SusDataset susSet2;
+  susMax1227::SusDataset susSet2;
-  SUS::SusDataset susSet3;
+  susMax1227::SusDataset susSet3;
-  SUS::SusDataset susSet4;
+  susMax1227::SusDataset susSet4;
-  SUS::SusDataset susSet5;
+  susMax1227::SusDataset susSet5;
-  SUS::SusDataset susSet6;
+  susMax1227::SusDataset susSet6;
-  SUS::SusDataset susSet7;
+  susMax1227::SusDataset susSet7;
-  SUS::SusDataset susSet8;
+  susMax1227::SusDataset susSet8;
-  SUS::SusDataset susSet9;
+  susMax1227::SusDataset susSet9;
-  SUS::SusDataset susSet10;
+  susMax1227::SusDataset susSet10;
-  SUS::SusDataset susSet11;
+  susMax1227::SusDataset susSet11;
 
   // TempLimits
   TempLimits acsBoardLimits = TempLimits(-40.0, -40.0, 80.0, 85.0, 85.0);

mission/controller/acs/SensorValues.h

@@ -4,13 +4,13 @@
 #include <mission/devices/devicedefinitions/gyroAdisHelpers.h>
 #include <mission/devices/devicedefinitions/imtqHelpers.h>
 #include <mission/devices/devicedefinitions/rwHelpers.h>
+#include <mission/devices/devicedefinitions/susMax1227Helpers.h>
 
 #include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
 #include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h"
 #include "fsfw_hal/devicehandlers/MgmRM3100Handler.h"
 #include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
 #include "mission/devices/devicedefinitions/GPSDefinitions.h"
-#include "mission/devices/devicedefinitions/SusDefinitions.h"
 
 namespace ACS {
 
@@ -36,19 +36,19 @@ class SensorValues {
   imtq::RawMtmMeasurementNoTorque imtqMgmSet =
       imtq::RawMtmMeasurementNoTorque(objects::IMTQ_HANDLER);
 
-  std::array<SUS::SusDataset, 12> susSets{
+  std::array<susMax1227::SusDataset, 12> susSets{
-      SUS::SusDataset(objects::SUS_0_N_LOC_XFYFZM_PT_XF),
+      susMax1227::SusDataset(objects::SUS_0_N_LOC_XFYFZM_PT_XF),
-      SUS::SusDataset(objects::SUS_1_N_LOC_XBYFZM_PT_XB),
+      susMax1227::SusDataset(objects::SUS_1_N_LOC_XBYFZM_PT_XB),
-      SUS::SusDataset(objects::SUS_2_N_LOC_XFYBZB_PT_YB),
+      susMax1227::SusDataset(objects::SUS_2_N_LOC_XFYBZB_PT_YB),
-      SUS::SusDataset(objects::SUS_3_N_LOC_XFYBZF_PT_YF),
+      susMax1227::SusDataset(objects::SUS_3_N_LOC_XFYBZF_PT_YF),
-      SUS::SusDataset(objects::SUS_4_N_LOC_XMYFZF_PT_ZF),
+      susMax1227::SusDataset(objects::SUS_4_N_LOC_XMYFZF_PT_ZF),
-      SUS::SusDataset(objects::SUS_5_N_LOC_XFYMZB_PT_ZB),
+      susMax1227::SusDataset(objects::SUS_5_N_LOC_XFYMZB_PT_ZB),
-      SUS::SusDataset(objects::SUS_6_R_LOC_XFYBZM_PT_XF),
+      susMax1227::SusDataset(objects::SUS_6_R_LOC_XFYBZM_PT_XF),
-      SUS::SusDataset(objects::SUS_7_R_LOC_XBYBZM_PT_XB),
+      susMax1227::SusDataset(objects::SUS_7_R_LOC_XBYBZM_PT_XB),
-      SUS::SusDataset(objects::SUS_8_R_LOC_XBYBZB_PT_YB),
+      susMax1227::SusDataset(objects::SUS_8_R_LOC_XBYBZB_PT_YB),
-      SUS::SusDataset(objects::SUS_9_R_LOC_XBYBZB_PT_YF),
+      susMax1227::SusDataset(objects::SUS_9_R_LOC_XBYBZB_PT_YF),
-      SUS::SusDataset(objects::SUS_10_N_LOC_XMYBZF_PT_ZF),
+      susMax1227::SusDataset(objects::SUS_10_N_LOC_XMYBZF_PT_ZF),
-      SUS::SusDataset(objects::SUS_11_R_LOC_XBYMZB_PT_ZB),
+      susMax1227::SusDataset(objects::SUS_11_R_LOC_XBYMZB_PT_ZB),
   };
 
   AdisGyroPrimaryDataset gyr0AdisSet = AdisGyroPrimaryDataset(objects::GYRO_0_ADIS_HANDLER);

mission/core/pollingSeqTables.cpp

@@ -191,21 +191,7 @@ ReturnValue_t pst::pstTcsAndAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg
   uint32_t length = thisSequence->getPeriodMs();
 
   // SUS: 16 ms
-  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 (cfg.scheduleSus) {
-    if (addSus0) {
     /* Write setup */
     thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0,
                           DeviceHandlerIF::PERFORM_OPERATION);
@@ -213,264 +199,122 @@ ReturnValue_t pst::pstTcsAndAcs(FixedTimeslotTaskIF *thisSequence, AcsPstCfg cfg
                           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,
+    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
-                            DeviceHandlerIF::SEND_READ);
+                          DeviceHandlerIF::PERFORM_OPERATION);
-      thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF, length * 0,
+    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
-                            DeviceHandlerIF::GET_READ);
-
-      thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF,
-                            length * config::acs::SCHED_BLOCK_1_PERIOD,
                           DeviceHandlerIF::SEND_WRITE);
-      thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF,
+    thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB, length * 0,
-                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
+                          DeviceHandlerIF::GET_WRITE);
+    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_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_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_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_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_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_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_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_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_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_0_N_LOC_XFYFZM_PT_XF,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::SUS_0_N_LOC_XFYFZM_PT_XF,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, 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 * config::acs::SCHED_BLOCK_1_PERIOD,
-                            DeviceHandlerIF::SEND_WRITE);
-      thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB,
-                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::SUS_1_N_LOC_XBYFZM_PT_XB,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, 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 * config::acs::SCHED_BLOCK_1_PERIOD,
-                            DeviceHandlerIF::SEND_WRITE);
-      thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB,
-                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::SUS_2_N_LOC_XFYBZB_PT_YB,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, 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 * config::acs::SCHED_BLOCK_1_PERIOD,
-                            DeviceHandlerIF::SEND_WRITE);
-      thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF,
-                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::SUS_3_N_LOC_XFYBZF_PT_YF,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, 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 * config::acs::SCHED_BLOCK_1_PERIOD,
-                            DeviceHandlerIF::SEND_WRITE);
-      thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF,
-                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::SUS_4_N_LOC_XMYFZF_PT_ZF,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, 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 * config::acs::SCHED_BLOCK_1_PERIOD,
-                            DeviceHandlerIF::SEND_WRITE);
-      thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
-                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::SUS_5_N_LOC_XFYMZB_PT_ZB,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
     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);
-      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 * config::acs::SCHED_BLOCK_1_PERIOD,
-                            DeviceHandlerIF::SEND_WRITE);
-      thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF,
-                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::SUS_6_R_LOC_XFYBZM_PT_XF,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
     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);
-      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 * config::acs::SCHED_BLOCK_1_PERIOD,
-                            DeviceHandlerIF::SEND_WRITE);
-      thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB,
-                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::SUS_7_R_LOC_XBYBZM_PT_XB,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
     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);
-      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 * config::acs::SCHED_BLOCK_1_PERIOD,
-                            DeviceHandlerIF::SEND_WRITE);
-      thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB,
-                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::SUS_8_R_LOC_XBYBZB_PT_YB,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
     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);
-      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 * config::acs::SCHED_BLOCK_1_PERIOD,
-                            DeviceHandlerIF::SEND_WRITE);
-      thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF,
-                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::SUS_9_R_LOC_XBYBZB_PT_YF,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
     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);
-      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 * config::acs::SCHED_BLOCK_1_PERIOD,
-                            DeviceHandlerIF::SEND_WRITE);
-      thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF,
-                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::SUS_10_N_LOC_XMYBZF_PT_ZF,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
     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);
-      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 * config::acs::SCHED_BLOCK_1_PERIOD,
-                            DeviceHandlerIF::SEND_WRITE);
-      thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB,
-                            length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::SUS_11_R_LOC_XBYMZB_PT_ZB,
                           length * config::acs::SCHED_BLOCK_1_PERIOD, DeviceHandlerIF::GET_READ);
   }
-  }
 
   if (cfg.scheduleStr) {
     thisSequence->addSlot(objects::STAR_TRACKER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);

mission/devices/LegacySusHandler.cpp

@@ -0,0 +1,233 @@
+#include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/globalfunctions/arrayprinter.h>
+#include <mission/devices/LegacySusHandler.h>
+
+#include "OBSWConfig.h"
+
+LegacySusHandler::LegacySusHandler(object_id_t objectId, uint8_t susIdx, object_id_t comIF,
+                                   CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comIF, comCookie), divider(5), dataset(this), susIdx(susIdx) {}
+
+LegacySusHandler::~LegacySusHandler() {}
+
+void LegacySusHandler::doStartUp() {
+  if (comState == ComStates::IDLE) {
+    comState = ComStates::WRITE_SETUP;
+    commandExecuted = false;
+  }
+  if (comState == ComStates::WRITE_SETUP) {
+    if (commandExecuted) {
+      if (goToNormalModeImmediately) {
+        setMode(MODE_NORMAL);
+      } else {
+        setMode(_MODE_TO_ON);
+      }
+      commandExecuted = false;
+      if (clkMode == ClkModes::INT_CLOCKED) {
+        comState = ComStates::START_INT_CLOCKED_CONVERSIONS;
+      } else {
+        comState = ComStates::EXT_CLOCKED_CONVERSIONS;
+      }
+    }
+  }
+}
+
+void LegacySusHandler::doShutDown() {
+  setMode(_MODE_POWER_DOWN);
+  comState = ComStates::IDLE;
+}
+
+ReturnValue_t LegacySusHandler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  switch (comState) {
+    case (ComStates::IDLE): {
+      break;
+    }
+    case (ComStates::WRITE_SETUP): {
+      *id = susMax1227::WRITE_SETUP;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    case (ComStates::EXT_CLOCKED_CONVERSIONS): {
+      *id = susMax1227::READ_EXT_TIMED_CONVERSIONS;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    case (ComStates::START_INT_CLOCKED_CONVERSIONS): {
+      *id = susMax1227::START_INT_TIMED_CONVERSIONS;
+      comState = ComStates::READ_INT_CLOCKED_CONVERSIONS;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    case (ComStates::READ_INT_CLOCKED_CONVERSIONS): {
+      *id = susMax1227::READ_INT_TIMED_CONVERSIONS;
+      comState = ComStates::START_INT_CLOCKED_CONVERSIONS;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    case (ComStates::EXT_CLOCKED_TEMP): {
+      *id = susMax1227::READ_EXT_TIMED_TEMPS;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+  }
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t LegacySusHandler::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  if (comState == ComStates::WRITE_SETUP) {
+    *id = susMax1227::WRITE_SETUP;
+    return buildCommandFromCommand(*id, nullptr, 0);
+  }
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t LegacySusHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                        const uint8_t *commandData,
+                                                        size_t commandDataLen) {
+  using namespace max1227;
+  switch (deviceCommand) {
+    case (susMax1227::WRITE_SETUP): {
+      if (clkMode == ClkModes::INT_CLOCKED) {
+        cmdBuffer[0] = susMax1227::SETUP_INT_CLOKED;
+      } else {
+        cmdBuffer[0] = susMax1227::SETUP_EXT_CLOCKED;
+      }
+
+      rawPacket = cmdBuffer;
+      rawPacketLen = 1;
+      break;
+    }
+    case (susMax1227::START_INT_TIMED_CONVERSIONS): {
+      std::memset(cmdBuffer, 0, sizeof(cmdBuffer));
+      cmdBuffer[0] = max1227::buildResetByte(true);
+      cmdBuffer[1] = susMax1227::CONVERSION;
+      rawPacket = cmdBuffer;
+      rawPacketLen = 2;
+      break;
+    }
+    case (susMax1227::READ_INT_TIMED_CONVERSIONS): {
+      std::memset(cmdBuffer, 0, sizeof(cmdBuffer));
+      rawPacket = cmdBuffer;
+      rawPacketLen = susMax1227::SIZE_READ_INT_CONVERSIONS;
+      break;
+    }
+    case (susMax1227::READ_EXT_TIMED_CONVERSIONS): {
+      std::memset(cmdBuffer, 0, sizeof(cmdBuffer));
+      rawPacket = cmdBuffer;
+      for (uint8_t idx = 0; idx < 6; idx++) {
+        cmdBuffer[idx * 2] = buildConvByte(ScanModes::N_ONCE, idx, false);
+        cmdBuffer[idx * 2 + 1] = 0;
+      }
+      cmdBuffer[12] = 0x00;
+      rawPacketLen = susMax1227::SIZE_READ_EXT_CONVERSIONS;
+      break;
+    }
+    case (susMax1227::READ_EXT_TIMED_TEMPS): {
+      cmdBuffer[0] = buildConvByte(ScanModes::N_ONCE, 0, true);
+      std::memset(cmdBuffer + 1, 0, 24);
+      rawPacket = cmdBuffer;
+      rawPacketLen = 25;
+      break;
+    }
+    default:
+      return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
+  }
+  return returnvalue::OK;
+}
+
+void LegacySusHandler::fillCommandAndReplyMap() {
+  insertInCommandAndReplyMap(susMax1227::WRITE_SETUP, 1);
+  insertInCommandAndReplyMap(susMax1227::START_INT_TIMED_CONVERSIONS, 1);
+  insertInCommandAndReplyMap(susMax1227::READ_INT_TIMED_CONVERSIONS, 1, &dataset,
+                             susMax1227::SIZE_READ_INT_CONVERSIONS);
+  insertInCommandAndReplyMap(susMax1227::READ_EXT_TIMED_CONVERSIONS, 1, &dataset,
+                             susMax1227::SIZE_READ_EXT_CONVERSIONS);
+  insertInCommandAndReplyMap(susMax1227::READ_EXT_TIMED_TEMPS, 1);
+}
+
+ReturnValue_t LegacySusHandler::scanForReply(const uint8_t *start, size_t remainingSize,
+                                             DeviceCommandId_t *foundId, size_t *foundLen) {
+  *foundId = this->getPendingCommand();
+  *foundLen = remainingSize;
+  return returnvalue::OK;
+}
+
+ReturnValue_t LegacySusHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  switch (id) {
+    case susMax1227::WRITE_SETUP: {
+      if (getMode() == _MODE_START_UP) {
+        commandExecuted = true;
+      }
+      return returnvalue::OK;
+    }
+    case susMax1227::START_INT_TIMED_CONVERSIONS: {
+      return returnvalue::OK;
+    }
+    case susMax1227::READ_INT_TIMED_CONVERSIONS: {
+      PoolReadGuard readSet(&dataset);
+      dataset.tempC = max1227::getTemperature(((packet[0] & 0x0f) << 8) | packet[1]);
+      for (uint8_t idx = 0; idx < 6; idx++) {
+        dataset.channels[idx] = packet[idx * 2 + 2] << 8 | packet[idx * 2 + 3];
+      }
+      dataset.setValidity(true, true);
+      printDataset();
+      break;
+    }
+    case (susMax1227::READ_EXT_TIMED_CONVERSIONS): {
+      PoolReadGuard readSet(&dataset);
+      for (uint8_t idx = 0; idx < 6; idx++) {
+        dataset.channels[idx] = packet[idx * 2 + 1] << 8 | packet[idx * 2 + 2];
+      }
+      dataset.channels.setValid(true);
+      // Read temperature in next read cycle
+      if (clkMode == ClkModes::EXT_CLOCKED_WITH_TEMP) {
+        comState = ComStates::EXT_CLOCKED_TEMP;
+      }
+      printDataset();
+      break;
+    }
+    case (susMax1227::READ_EXT_TIMED_TEMPS): {
+      PoolReadGuard readSet(&dataset);
+      dataset.tempC = max1227::getTemperature(((packet[23] & 0x0f) << 8) | packet[24]);
+      dataset.tempC.setValid(true);
+      comState = ComStates::EXT_CLOCKED_CONVERSIONS;
+      break;
+    }
+    default: {
+      sif::debug << "SusHandler::interpretDeviceReply: Unknown reply id" << std::endl;
+      return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
+    }
+  }
+  return returnvalue::OK;
+}
+
+uint32_t LegacySusHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 3000; }
+
+ReturnValue_t LegacySusHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                        LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(susMax1227::TEMPERATURE_C, &tempC);
+  localDataPoolMap.emplace(susMax1227::CHANNEL_VEC, &channelVec);
+  poolManager.subscribeForDiagPeriodicPacket(
+      subdp::DiagnosticsHkPeriodicParams(dataset.getSid(), false, 5.0));
+  return returnvalue::OK;
+}
+
+void LegacySusHandler::setToGoToNormalMode(bool enable) {
+  this->goToNormalModeImmediately = enable;
+}
+
+void LegacySusHandler::printDataset() {
+  if (periodicPrintout) {
+    if (divider.checkAndIncrement()) {
+      sif::info << "SUS ADC " << static_cast<int>(susIdx) << " hex [" << std::setfill('0')
+                << std::hex;
+      for (uint8_t idx = 0; idx < 6; idx++) {
+        sif::info << std::setw(3) << dataset.channels[idx];
+        if (idx < 6 - 1) {
+          sif::info << ",";
+        }
+      }
+      sif::info << "] | T[C] " << std::dec << dataset.tempC.value << std::endl;
+    }
+  }
+}
+
+void LegacySusHandler::enablePeriodicPrintout(bool enable, uint8_t divider) {
+  this->periodicPrintout = enable;
+  this->divider.setDivider(divider);
+}

mission/devices/LegacySusHandler.h

@@ -0,0 +1,92 @@
+#ifndef MISSION_DEVICES_LEGACYSUSHANDLER_H_
+#define MISSION_DEVICES_LEGACYSUSHANDLER_H_
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <mission/devices/devicedefinitions/susMax1227Helpers.h>
+
+#include "events/subsystemIdRanges.h"
+#include "fsfw/globalfunctions/PeriodicOperationDivider.h"
+#include "mission/devices/max1227.h"
+#include "returnvalues/classIds.h"
+
+/**
+ * @brief	This is the device handler class for the SUS sensor based on the MAX1227 ADC.
+ *
+ * @details
+ * Datasheet of MAX1227: https://datasheets.maximintegrated.com/en/ds/MAX1227-MAX1231.pdf
+ * Details about the SUS electronic can be found at
+ * https://egit.irs.uni-stuttgart.de/eive/eive_dokumente/src/branch/master/400_Raumsegment/443_SunSensorDocumentation/release
+ *
+ * @note    When adding a SusHandler to the polling sequence table make sure to add a slot with
+ *          the executionStep FIRST_WRITE. Otherwise the communication sequence will never be
+ *          started.
+ *
+ * @author	J. Meier
+ */
+class LegacySusHandler : public DeviceHandlerBase {
+ public:
+  enum ClkModes { INT_CLOCKED, EXT_CLOCKED, EXT_CLOCKED_WITH_TEMP };
+
+  static const uint8_t FIRST_WRITE = 7;
+
+  LegacySusHandler(object_id_t objectId, uint8_t susIdx, object_id_t comIF, CookieIF* comCookie);
+  virtual ~LegacySusHandler();
+
+  void enablePeriodicPrintout(bool enable, uint8_t divider);
+
+  void setToGoToNormalMode(bool enable);
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
+  void fillCommandAndReplyMap() override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t* commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId,
+                             size_t* foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                        LocalDataPoolManager& poolManager) override;
+
+ private:
+  static const uint8_t INTERFACE_ID = CLASS_ID::SUS_HANDLER;
+
+  static const ReturnValue_t ERROR_UNLOCK_MUTEX = MAKE_RETURN_CODE(0xA0);
+  static const ReturnValue_t ERROR_LOCK_MUTEX = MAKE_RETURN_CODE(0xA1);
+
+  enum class ComStates {
+    IDLE,
+    WRITE_SETUP,
+    EXT_CLOCKED_CONVERSIONS,
+    EXT_CLOCKED_TEMP,
+    START_INT_CLOCKED_CONVERSIONS,
+    READ_INT_CLOCKED_CONVERSIONS
+  };
+
+  bool periodicPrintout = false;
+  PeriodicOperationDivider divider;
+  bool goToNormalModeImmediately = false;
+  bool commandExecuted = false;
+
+  susMax1227::SusDataset dataset;
+  // Read temperature in each alternating communication step when using
+  // externally clocked mode
+  ClkModes clkMode = ClkModes::INT_CLOCKED;
+  PoolEntry<float> tempC = PoolEntry<float>({0.0});
+  PoolEntry<uint16_t> channelVec = PoolEntry<uint16_t>({0, 0, 0, 0, 0, 0});
+
+  uint8_t susIdx = 0;
+  uint8_t cmdBuffer[susMax1227::MAX_CMD_SIZE];
+  ComStates comState = ComStates::IDLE;
+
+  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+  uint32_t timeoutMs = 20;
+  void printDataset();
+
+  MutexIF* spiMutex = nullptr;
+};
+
+#endif /* MISSION_DEVICES_LEGACYSUSHANDLER_H_ */

mission/devices/SusHandler.cpp

@@ -1,231 +1,128 @@
 #include "SusHandler.h"
 
-#include <fsfw/datapool/PoolReadGuard.h>
+#include <mission/devices/max1227.h>
-#include <fsfw/globalfunctions/arrayprinter.h>
 
-#include "OBSWConfig.h"
+#include <cmath>
 
-SusHandler::SusHandler(object_id_t objectId, uint8_t susIdx, object_id_t comIF, CookieIF *comCookie)
+#include "fsfw/datapool/PoolReadGuard.h"
-    : DeviceHandlerBase(objectId, comIF, comCookie), divider(5), dataset(this), susIdx(susIdx) {}
 
-SusHandler::~SusHandler() {}
+SusHandler::SusHandler(object_id_t objectId, uint8_t susIdx, object_id_t deviceCommunication,
+                       CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, deviceCommunication, comCookie), dataset(this), susIdx(susIdx) {}
+
+SusHandler::~SusHandler() = default;
 
 void SusHandler::doStartUp() {
-  if (comState == ComStates::IDLE) {
+  if (internalState != InternalState::STARTUP) {
-    comState = ComStates::WRITE_SETUP;
     commandExecuted = false;
+    updatePeriodicReply(true, REPLY);
+    internalState = InternalState::STARTUP;
   }
-  if (comState == ComStates::WRITE_SETUP) {
+  if (internalState == InternalState::STARTUP) {
     if (commandExecuted) {
-      if (goToNormalModeImmediately) {
       setMode(MODE_NORMAL);
-      } else {
+      internalState = InternalState::NONE;
-        setMode(_MODE_TO_ON);
-      }
       commandExecuted = false;
-      if (clkMode == ClkModes::INT_CLOCKED) {
-        comState = ComStates::START_INT_CLOCKED_CONVERSIONS;
-      } else {
-        comState = ComStates::EXT_CLOCKED_CONVERSIONS;
-      }
     }
   }
 }
 
 void SusHandler::doShutDown() {
+  if (internalState != InternalState::SHUTDOWN) {
+    dataset.setValidity(false, true);
+    internalState = InternalState::SHUTDOWN;
+    commandExecuted = false;
+  }
+  if (internalState == InternalState::SHUTDOWN and commandExecuted) {
+    updatePeriodicReply(false, REPLY);
+    commandExecuted = false;
+    internalState = InternalState::NONE;
     setMode(_MODE_POWER_DOWN);
-  comState = ComStates::IDLE;
-}
-
-ReturnValue_t SusHandler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
-  switch (comState) {
-    case (ComStates::IDLE): {
-      break;
   }
-    case (ComStates::WRITE_SETUP): {
-      *id = SUS::WRITE_SETUP;
-      return buildCommandFromCommand(*id, nullptr, 0);
-    }
-    case (ComStates::EXT_CLOCKED_CONVERSIONS): {
-      *id = SUS::READ_EXT_TIMED_CONVERSIONS;
-      return buildCommandFromCommand(*id, nullptr, 0);
-    }
-    case (ComStates::START_INT_CLOCKED_CONVERSIONS): {
-      *id = SUS::START_INT_TIMED_CONVERSIONS;
-      comState = ComStates::READ_INT_CLOCKED_CONVERSIONS;
-      return buildCommandFromCommand(*id, nullptr, 0);
-    }
-    case (ComStates::READ_INT_CLOCKED_CONVERSIONS): {
-      *id = SUS::READ_INT_TIMED_CONVERSIONS;
-      comState = ComStates::START_INT_CLOCKED_CONVERSIONS;
-      return buildCommandFromCommand(*id, nullptr, 0);
-    }
-    case (ComStates::EXT_CLOCKED_TEMP): {
-      *id = SUS::READ_EXT_TIMED_TEMPS;
-      return buildCommandFromCommand(*id, nullptr, 0);
-    }
-  }
-  return NOTHING_TO_SEND;
 }
 
 ReturnValue_t SusHandler::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
-  if (comState == ComStates::WRITE_SETUP) {
+  if (internalState == InternalState::STARTUP) {
-    *id = SUS::WRITE_SETUP;
+    *id = REQUEST;
-    return buildCommandFromCommand(*id, nullptr, 0);
+    return prepareRequest(acs::SimpleSensorMode::NORMAL);
+  } else if (internalState == InternalState::SHUTDOWN) {
+    *id = REQUEST;
+    return prepareRequest(acs::SimpleSensorMode::OFF);
   }
   return NOTHING_TO_SEND;
 }
 
+ReturnValue_t SusHandler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  *id = REQUEST;
+  return prepareRequest(acs::SimpleSensorMode::NORMAL);
+}
+
 ReturnValue_t SusHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
                                                   const uint8_t *commandData,
                                                   size_t commandDataLen) {
-  using namespace max1227;
+  return NOTHING_TO_SEND;
-  switch (deviceCommand) {
+}
-    case (SUS::WRITE_SETUP): {
-      if (clkMode == ClkModes::INT_CLOCKED) {
-        cmdBuffer[0] = SUS::SETUP_INT_CLOKED;
-      } else {
-        cmdBuffer[0] = SUS::SETUP_EXT_CLOCKED;
-      }
 
-      rawPacket = cmdBuffer;
+ReturnValue_t SusHandler::scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
-      rawPacketLen = 1;
+                                       size_t *foundLen) {
-      break;
+  if (getMode() == _MODE_WAIT_OFF or getMode() == _MODE_WAIT_ON) {
+    return IGNORE_FULL_PACKET;
   }
-    case (SUS::START_INT_TIMED_CONVERSIONS): {
+  if (len != sizeof(acs::SusReply)) {
-      std::memset(cmdBuffer, 0, sizeof(cmdBuffer));
+    *foundLen = len;
-      cmdBuffer[0] = max1227::buildResetByte(true);
+    return returnvalue::FAILED;
-      cmdBuffer[1] = SUS::CONVERSION;
-      rawPacket = cmdBuffer;
-      rawPacketLen = 2;
-      break;
   }
-    case (SUS::READ_INT_TIMED_CONVERSIONS): {
+  *foundId = REPLY;
-      std::memset(cmdBuffer, 0, sizeof(cmdBuffer));
+  *foundLen = len;
-      rawPacket = cmdBuffer;
+  if (internalState == InternalState::SHUTDOWN) {
-      rawPacketLen = SUS::SIZE_READ_INT_CONVERSIONS;
+    commandExecuted = true;
-      break;
   }
-    case (SUS::READ_EXT_TIMED_CONVERSIONS): {
+  return returnvalue::OK;
-      std::memset(cmdBuffer, 0, sizeof(cmdBuffer));
+}
-      rawPacket = cmdBuffer;
+ReturnValue_t SusHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-      for (uint8_t idx = 0; idx < 6; idx++) {
+  const auto *reply = reinterpret_cast<const acs::SusReply *>(packet);
-        cmdBuffer[idx * 2] = buildConvByte(ScanModes::N_ONCE, idx, false);
+  if (reply->dataWasSet) {
-        cmdBuffer[idx * 2 + 1] = 0;
+    if (internalState == InternalState::STARTUP) {
+      commandExecuted = true;
     }
-      cmdBuffer[12] = 0x00;
+    PoolReadGuard pg(&dataset);
-      rawPacketLen = SUS::SIZE_READ_EXT_CONVERSIONS;
+    dataset.setValidity(true, true);
-      break;
+    dataset.tempC = max1227::getTemperature(reply->tempRaw);
-    }
+    std::memcpy(dataset.channels.value, reply->channelsRaw, sizeof(reply->channelsRaw));
-    case (SUS::READ_EXT_TIMED_TEMPS): {
-      cmdBuffer[0] = buildConvByte(ScanModes::N_ONCE, 0, true);
-      std::memset(cmdBuffer + 1, 0, 24);
-      rawPacket = cmdBuffer;
-      rawPacketLen = 25;
-      break;
-    }
-    default:
-      return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
   }
   return returnvalue::OK;
 }
 
 void SusHandler::fillCommandAndReplyMap() {
-  insertInCommandAndReplyMap(SUS::WRITE_SETUP, 1);
+  insertInCommandMap(REQUEST);
-  insertInCommandAndReplyMap(SUS::START_INT_TIMED_CONVERSIONS, 1);
+  insertInReplyMap(REPLY, 5, nullptr, 0, true);
-  insertInCommandAndReplyMap(SUS::READ_INT_TIMED_CONVERSIONS, 1, &dataset,
-                             SUS::SIZE_READ_INT_CONVERSIONS);
-  insertInCommandAndReplyMap(SUS::READ_EXT_TIMED_CONVERSIONS, 1, &dataset,
-                             SUS::SIZE_READ_EXT_CONVERSIONS);
-  insertInCommandAndReplyMap(SUS::READ_EXT_TIMED_TEMPS, 1);
 }
 
-ReturnValue_t SusHandler::scanForReply(const uint8_t *start, size_t remainingSize,
+void SusHandler::setToGoToNormalMode(bool enable) { this->goToNormalMode = enable; }
-                                       DeviceCommandId_t *foundId, size_t *foundLen) {
-  *foundId = this->getPendingCommand();
-  *foundLen = remainingSize;
-  return returnvalue::OK;
-}
 
-ReturnValue_t SusHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+uint32_t SusHandler::getTransitionDelayMs(Mode_t from, Mode_t to) { return transitionDelay; }
-  switch (id) {
-    case SUS::WRITE_SETUP: {
-      if (getMode() == _MODE_START_UP) {
-        commandExecuted = true;
-      }
-      return returnvalue::OK;
-    }
-    case SUS::START_INT_TIMED_CONVERSIONS: {
-      return returnvalue::OK;
-    }
-    case SUS::READ_INT_TIMED_CONVERSIONS: {
-      PoolReadGuard readSet(&dataset);
-      dataset.temperatureCelcius = max1227::getTemperature(((packet[0] & 0x0f) << 8) | packet[1]);
-      for (uint8_t idx = 0; idx < 6; idx++) {
-        dataset.channels[idx] = packet[idx * 2 + 2] << 8 | packet[idx * 2 + 3];
-      }
-      dataset.setValidity(true, true);
-      printDataset();
-      break;
-    }
-    case (SUS::READ_EXT_TIMED_CONVERSIONS): {
-      PoolReadGuard readSet(&dataset);
-      for (uint8_t idx = 0; idx < 6; idx++) {
-        dataset.channels[idx] = packet[idx * 2 + 1] << 8 | packet[idx * 2 + 2];
-      }
-      dataset.channels.setValid(true);
-      // Read temperature in next read cycle
-      if (clkMode == ClkModes::EXT_CLOCKED_WITH_TEMP) {
-        comState = ComStates::EXT_CLOCKED_TEMP;
-      }
-      printDataset();
-      break;
-    }
-    case (SUS::READ_EXT_TIMED_TEMPS): {
-      PoolReadGuard readSet(&dataset);
-      dataset.temperatureCelcius = max1227::getTemperature(((packet[23] & 0x0f) << 8) | packet[24]);
-      dataset.temperatureCelcius.setValid(true);
-      comState = ComStates::EXT_CLOCKED_CONVERSIONS;
-      break;
-    }
-    default: {
-      sif::debug << "SusHandler::interpretDeviceReply: Unknown reply id" << std::endl;
-      return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
-    }
-  }
-  return returnvalue::OK;
-}
 
-uint32_t SusHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 3000; }
+void SusHandler::modeChanged(void) { internalState = InternalState::NONE; }
 
 ReturnValue_t SusHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                                   LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(SUS::TEMPERATURE_C, &tempC);
+  localDataPoolMap.emplace(susMax1227::TEMPERATURE_C, &tempC);
-  localDataPoolMap.emplace(SUS::CHANNEL_VEC, &channelVec);
+  localDataPoolMap.emplace(susMax1227::CHANNEL_VEC, &channelVec);
   poolManager.subscribeForDiagPeriodicPacket(
       subdp::DiagnosticsHkPeriodicParams(dataset.getSid(), false, 5.0));
   return returnvalue::OK;
 }
 
-void SusHandler::setToGoToNormalMode(bool enable) { this->goToNormalModeImmediately = enable; }
+ReturnValue_t SusHandler::prepareRequest(acs::SimpleSensorMode mode) {
-
+  request.mode = mode;
-void SusHandler::printDataset() {
+  rawPacket = reinterpret_cast<uint8_t *>(&request);
-  if (periodicPrintout) {
+  rawPacketLen = sizeof(acs::SusRequest);
-    if (divider.checkAndIncrement()) {
+  return returnvalue::OK;
-      sif::info << "SUS ADC " << static_cast<int>(susIdx) << " hex [" << std::setfill('0')
-                << std::hex;
-      for (uint8_t idx = 0; idx < 6; idx++) {
-        sif::info << std::setw(3) << dataset.channels[idx];
-        if (idx < 6 - 1) {
-          sif::info << ",";
-        }
-      }
-      sif::info << "] | T[C] " << std::dec << dataset.temperatureCelcius.value << std::endl;
-    }
-  }
 }
 
-void SusHandler::enablePeriodicPrintout(bool enable, uint8_t divider) {
+LocalPoolDataSetBase *SusHandler::getDataSetHandle(sid_t sid) {
-  this->periodicPrintout = enable;
+  if (sid == dataset.getSid()) {
-  this->divider.setDivider(divider);
+    return &dataset;
+  }
+  return nullptr;
 }

mission/devices/SusHandler.h

@@ -1,92 +1,65 @@
-#ifndef MISSION_DEVICES_SUSHANDLER_H_
+#ifndef MISSION_DEVICES_SusHandler_H_
-#define MISSION_DEVICES_SUSHANDLER_H_
+#define MISSION_DEVICES_SusHandler_H_
 
-#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include "fsfw/devicehandlers/DeviceHandlerBase.h"
-
-#include "devicedefinitions/SusDefinitions.h"
-#include "events/subsystemIdRanges.h"
 #include "fsfw/globalfunctions/PeriodicOperationDivider.h"
-#include "mission/devices/max1227.h"
+#include "mission/devices/devicedefinitions/acsPolling.h"
-#include "returnvalues/classIds.h"
+#include "mission/devices/devicedefinitions/susMax1227Helpers.h"
 
-/**
- * @brief	This is the device handler class for the SUS sensor based on the MAX1227 ADC.
- *
- * @details
- * Datasheet of MAX1227: https://datasheets.maximintegrated.com/en/ds/MAX1227-MAX1231.pdf
- * Details about the SUS electronic can be found at
- * https://egit.irs.uni-stuttgart.de/eive/eive_dokumente/src/branch/master/400_Raumsegment/443_SunSensorDocumentation/release
- *
- * @note    When adding a SusHandler to the polling sequence table make sure to add a slot with
- *          the executionStep FIRST_WRITE. Otherwise the communication sequence will never be
- *          started.
- *
- * @author	J. Meier
- */
 class SusHandler : public DeviceHandlerBase {
  public:
-  enum ClkModes { INT_CLOCKED, EXT_CLOCKED, EXT_CLOCKED_WITH_TEMP };
+  static constexpr DeviceCommandId_t REQUEST = 0x70;
+  static constexpr DeviceCommandId_t REPLY = 0x77;
 
-  static const uint8_t FIRST_WRITE = 7;
+  static const uint8_t INTERFACE_ID = CLASS_ID::SUS_HANDLER;
+  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::SUS_BOARD_ASS;
 
-  SusHandler(object_id_t objectId, uint8_t susIdx, object_id_t comIF, CookieIF* comCookie);
+  SusHandler(uint32_t objectId, uint8_t susIdx, object_id_t deviceCommunication,
+             CookieIF *comCookie);
   virtual ~SusHandler();
 
-  void enablePeriodicPrintout(bool enable, uint8_t divider);
+  void enablePeriodicPrintouts(bool enable, uint8_t divider);
-
   void setToGoToNormalMode(bool enable);
 
  protected:
-  void doStartUp() override;
+  /** DeviceHandlerBase overrides */
   void doShutDown() override;
-  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
+  void doStartUp() override;
-  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
+  uint32_t getTransitionDelayMs(Mode_t from, Mode_t to) override;
-  void fillCommandAndReplyMap() override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
-  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,
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
-                             size_t* foundLen) override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
-  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
-  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+                             size_t *foundLen) override;
-  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
-                                        LocalDataPoolManager& poolManager) override;
+  void fillCommandAndReplyMap() override;
+  void modeChanged(void) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+  LocalPoolDataSetBase *getDataSetHandle(sid_t sid) override;
 
  private:
-  static const uint8_t INTERFACE_ID = CLASS_ID::SUS_HANDLER;
+  susMax1227::SusDataset dataset;
+  acs::SusRequest request{};
+  uint8_t susIdx;
 
-  static const ReturnValue_t ERROR_UNLOCK_MUTEX = MAKE_RETURN_CODE(0xA0);
+  uint32_t transitionDelay = 1000;
-  static const ReturnValue_t ERROR_LOCK_MUTEX = MAKE_RETURN_CODE(0xA1);
+  bool goToNormalMode = false;
 
-  enum class ComStates {
-    IDLE,
-    WRITE_SETUP,
-    EXT_CLOCKED_CONVERSIONS,
-    EXT_CLOCKED_TEMP,
-    START_INT_CLOCKED_CONVERSIONS,
-    READ_INT_CLOCKED_CONVERSIONS
-  };
-
-  bool periodicPrintout = false;
-  PeriodicOperationDivider divider;
-  bool goToNormalModeImmediately = false;
-  bool commandExecuted = false;
-
-  SUS::SusDataset dataset;
-  // Read temperature in each alternating communication step when using
-  // externally clocked mode
-  ClkModes clkMode = ClkModes::INT_CLOCKED;
   PoolEntry<float> tempC = PoolEntry<float>({0.0});
   PoolEntry<uint16_t> channelVec = PoolEntry<uint16_t>({0, 0, 0, 0, 0, 0});
 
-  uint8_t susIdx = 0;
+  enum class InternalState {
-  uint8_t cmdBuffer[SUS::MAX_CMD_SIZE];
+    NONE,
-  ComStates comState = ComStates::IDLE;
+    STARTUP,
+    SHUTDOWN,
+  };
 
-  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+  InternalState internalState = InternalState::NONE;
-  uint32_t timeoutMs = 20;
+  bool commandExecuted = false;
-  void printDataset();
 
-  MutexIF* spiMutex = nullptr;
+  ReturnValue_t prepareRequest(acs::SimpleSensorMode mode);
 };
 
-#endif /* MISSION_DEVICES_SUSHANDLER_H_ */
+#endif /* MISSION_DEVICES_SusHandler_H_ */

mission/devices/devicedefinitions/acsPolling.h

@@ -76,6 +76,17 @@ struct MgmLis3Reply {
   int16_t temperatureRaw = thermal::INVALID_TEMPERATURE;
 };
 
+struct SusRequest {
+  SimpleSensorMode mode = SimpleSensorMode::OFF;
+};
+
+struct SusReply {
+  bool cfgWasSet = false;
+  bool dataWasSet = false;
+  uint16_t tempRaw = 0;
+  uint16_t channelsRaw[6]{};
+};
+
 }  // namespace acs
 
 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_ACSPOLLING_H_ */

mission/devices/devicedefinitions/susMax1227Helpers.h

@@ -6,7 +6,7 @@
 
 #include <cstdint>
 
-namespace SUS {
+namespace susMax1227 {
 
 static const DeviceCommandId_t NONE = 0x0;  // Set when no command is pending
 
@@ -69,9 +69,9 @@ class SusDataset : public StaticLocalDataSet<POOL_ENTRIES> {
 
   SusDataset(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, SUS_DATA_SET_ID)) {}
 
-  lp_var_t<float> temperatureCelcius = lp_var_t<float>(sid.objectId, TEMPERATURE_C, this);
+  lp_var_t<float> tempC = lp_var_t<float>(sid.objectId, TEMPERATURE_C, this);
   lp_vec_t<uint16_t, 6> channels = lp_vec_t<uint16_t, 6>(sid.objectId, CHANNEL_VEC, this);
 };
-}  // namespace SUS
+}  // namespace susMax1227
 
 #endif /* MISSION_DEVICES_DEVICEDEFINITIONS_SUS_H_ */

mission/system/objects/ComSubsystem.h

@@ -1,17 +1,16 @@
 #ifndef MISSION_SYSTEM_COMSUBSYSTEM_H_
 #define MISSION_SYSTEM_COMSUBSYSTEM_H_
 
+#include <common/config/eive/eventSubsystemIds.h>
 #include <fsfw/events/EventMessage.h>
 #include <fsfw/parameters/HasParametersIF.h>
 #include <fsfw/parameters/ParameterHelper.h>
 #include <fsfw/subsystem/Subsystem.h>
-#include <common/config/eive/eventSubsystemIds.h>
 
 #include "mission/comDefs.h"
 
 class ComSubsystem : public Subsystem, public ReceivesParameterMessagesIF {
  public:
-
   static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::COM_SUBSYSTEM;
 
   //! [EXPORT] : [COMMENT] The transmit timer to protect the Syrlinks expired
@@ -27,7 +26,8 @@ class ComSubsystem : public Subsystem, public ReceivesParameterMessagesIF {
    * @param maxNumberOfSequences
    * @param maxNumberOfTables
    * @param transmitterTimeout	Maximum time the transmitter of the syrlinks
-   * 														will be enabled
+   * 														will
+   * be enabled
    */
   ComSubsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables,
                uint32_t transmitterTimeout);