finish acs and com

linux/acs/AcsBoardPolling.cpp

@@ -0,0 +1,736 @@
+#include "AcsBoardPolling.h"
+
+#include <fcntl.h>
+#include <fsfw/globalfunctions/arrayprinter.h>
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
+#include <fsfw_hal/devicehandlers/devicedefinitions/gyroL3gHelpers.h>
+#include <fsfw_hal/devicehandlers/devicedefinitions/mgmLis3Helpers.h>
+#include <fsfw_hal/linux/UnixFileGuard.h>
+#include <fsfw_hal/linux/spi/SpiCookie.h>
+#include <fsfw_hal/linux/utility.h>
+#include <mission/acs/gyroAdisHelpers.h>
+#include <sys/ioctl.h>
+
+#include "devices/gpioIds.h"
+
+using namespace returnvalue;
+
+AcsBoardPolling::AcsBoardPolling(object_id_t objectId, SpiComIF& lowLevelComIF, GpioIF& gpioIF)
+    : SystemObject(objectId), spiComIF(lowLevelComIF), gpioIF(gpioIF) {
+  semaphore = SemaphoreFactory::instance()->createBinarySemaphore();
+  semaphore->acquire();
+  ipcLock = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t AcsBoardPolling::performOperation(uint8_t operationCode) {
+  while (true) {
+    ipcLock->lockMutex(LOCK_TYPE, LOCK_TIMEOUT);
+    state = InternalState::IDLE;
+    ipcLock->unlockMutex();
+    semaphore->acquire();
+    // Give all tasks or the PST some time to submit all consecutive requests.
+    TaskFactory::delayTask(2);
+    {
+      // Measured to take 0-1 ms in debug build.
+      // Stopwatch watch;
+      gyroAdisHandler(gyro0Adis);
+      gyroAdisHandler(gyro2Adis);
+      gyroL3gHandler(gyro1L3g);
+      gyroL3gHandler(gyro3L3g);
+      mgmRm3100Handler(mgm1Rm3100);
+      mgmRm3100Handler(mgm3Rm3100);
+      mgmLis3Handler(mgm0Lis3);
+      mgmLis3Handler(mgm2Lis3);
+    }
+    // To prevent task being not reactivated by tardy tasks
+    TaskFactory::delayTask(20);
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t AcsBoardPolling::initialize() { return returnvalue::OK; }
+
+ReturnValue_t AcsBoardPolling::initializeInterface(CookieIF* cookie) {
+  SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  if (spiCookie == nullptr) {
+    return returnvalue::FAILED;
+  }
+  switch (spiCookie->getChipSelectPin()) {
+    case (gpioIds::MGM_0_LIS3_CS): {
+      mgm0Lis3.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::MGM_1_RM3100_CS): {
+      mgm1Rm3100.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::MGM_2_LIS3_CS): {
+      mgm2Lis3.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::MGM_3_RM3100_CS): {
+      mgm3Rm3100.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::GYRO_0_ADIS_CS): {
+      gyro0Adis.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::GYRO_1_L3G_CS): {
+      gyro1L3g.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::GYRO_2_ADIS_CS): {
+      gyro2Adis.cookie = spiCookie;
+      break;
+    }
+    case (gpioIds::GYRO_3_L3G_CS): {
+      gyro3L3g.cookie = spiCookie;
+      break;
+    }
+    default: {
+      sif::error << "AcsBoardPollingTask: invalid spi cookie" << std::endl;
+    }
+  }
+  return spiComIF.initializeInterface(cookie);
+}
+
+ReturnValue_t AcsBoardPolling::sendMessage(CookieIF* cookie, const uint8_t* sendData,
+                                           size_t sendLen) {
+  SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  if (spiCookie == nullptr) {
+    return returnvalue::FAILED;
+  }
+  auto handleAdisRequest = [&](GyroAdis& adis) {
+    if (sendLen != sizeof(acs::Adis1650XRequest)) {
+      sif::error << "AcsBoardPolling: invalid adis request send length";
+      adis.replyResult = returnvalue::FAILED;
+      return returnvalue::FAILED;
+    }
+    auto* req = reinterpret_cast<const acs::Adis1650XRequest*>(sendData);
+    if (req->mode != adis.mode) {
+      if (req->mode == acs::SimpleSensorMode::NORMAL) {
+        adis.type = req->type;
+        adis.countdown.setTimeout(adis1650x::START_UP_TIME);
+        if (adis.type == adis1650x::Type::ADIS16507) {
+          adis.ownReply.data.accelScaling = adis1650x::ACCELEROMETER_RANGE_16507;
+        } else if (adis.type == adis1650x::Type::ADIS16505) {
+          adis.ownReply.data.accelScaling = adis1650x::ACCELEROMETER_RANGE_16505;
+        } else {
+          sif::warning << "AcsBoardPolling: Unknown ADIS type" << std::endl;
+        }
+        adis.performStartup = true;
+      } else if (req->mode == acs::SimpleSensorMode::OFF) {
+        adis.performStartup = false;
+        adis.ownReply.cfgWasSet = false;
+        adis.ownReply.dataWasSet = false;
+      }
+      adis.mode = req->mode;
+    }
+    return returnvalue::OK;
+  };
+  auto handleL3gRequest = [&](GyroL3g& gyro) {
+    if (sendLen != sizeof(acs::GyroL3gRequest)) {
+      sif::error << "AcsBoardPolling: invalid l3g request send length";
+      gyro.replyResult = returnvalue::FAILED;
+      return returnvalue::FAILED;
+    }
+    auto* req = reinterpret_cast<const acs::GyroL3gRequest*>(sendData);
+    if (req->mode != gyro.mode) {
+      if (req->mode == acs::SimpleSensorMode::NORMAL) {
+        std::memcpy(gyro.sensorCfg, req->ctrlRegs, 5);
+        gyro.performStartup = true;
+      } else {
+        gyro.ownReply.cfgWasSet = false;
+      }
+      gyro.mode = req->mode;
+    }
+    return returnvalue::OK;
+  };
+  auto handleLis3Request = [&](MgmLis3& mgm) {
+    if (sendLen != sizeof(acs::MgmLis3Request)) {
+      sif::error << "AcsBoardPolling: invalid lis3 request send length";
+      mgm.replyResult = returnvalue::FAILED;
+      return returnvalue::FAILED;
+    }
+    auto* req = reinterpret_cast<const acs::MgmLis3Request*>(sendData);
+    if (req->mode != mgm.mode) {
+      if (req->mode == acs::SimpleSensorMode::NORMAL) {
+        mgm.performStartup = true;
+      } else {
+        mgm.ownReply.dataWasSet = false;
+        mgm.ownReply.temperatureWasSet = false;
+      }
+      mgm.mode = req->mode;
+    }
+    return returnvalue::OK;
+  };
+  auto handleRm3100Request = [&](MgmRm3100& mgm) {
+    if (sendLen != sizeof(acs::MgmRm3100Request)) {
+      sif::error << "AcsBoardPolling: invalid rm3100 request send length";
+      mgm.replyResult = returnvalue::FAILED;
+      return returnvalue::FAILED;
+    }
+    auto* req = reinterpret_cast<const acs::MgmRm3100Request*>(sendData);
+    if (req->mode != mgm.mode) {
+      if (req->mode == acs::SimpleSensorMode::NORMAL) {
+        mgm.performStartup = true;
+      } else {
+        mgm.ownReply.dataWasRead = false;
+      }
+      mgm.mode = req->mode;
+    }
+    return returnvalue::OK;
+  };
+  {
+    MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+    switch (spiCookie->getChipSelectPin()) {
+      case (gpioIds::MGM_0_LIS3_CS): {
+        handleLis3Request(mgm0Lis3);
+        break;
+      }
+      case (gpioIds::MGM_1_RM3100_CS): {
+        handleRm3100Request(mgm1Rm3100);
+        break;
+      }
+      case (gpioIds::MGM_2_LIS3_CS): {
+        handleLis3Request(mgm2Lis3);
+        break;
+      }
+      case (gpioIds::MGM_3_RM3100_CS): {
+        handleRm3100Request(mgm3Rm3100);
+        break;
+      }
+      case (gpioIds::GYRO_0_ADIS_CS): {
+        handleAdisRequest(gyro0Adis);
+        break;
+      }
+      case (gpioIds::GYRO_2_ADIS_CS): {
+        handleAdisRequest(gyro2Adis);
+        break;
+      }
+      case (gpioIds::GYRO_1_L3G_CS): {
+        handleL3gRequest(gyro1L3g);
+        break;
+      }
+      case (gpioIds::GYRO_3_L3G_CS): {
+        handleL3gRequest(gyro3L3g);
+        break;
+      }
+    }
+    if (state == InternalState::IDLE) {
+      state = InternalState::IS_BUSY;
+    }
+  }
+  semaphore->release();
+  return returnvalue::OK;
+}
+
+ReturnValue_t AcsBoardPolling::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
+
+ReturnValue_t AcsBoardPolling::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t AcsBoardPolling::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
+                                                   size_t* size) {
+  SpiCookie* spiCookie = dynamic_cast<SpiCookie*>(cookie);
+  if (spiCookie == nullptr) {
+    return returnvalue::FAILED;
+  }
+  MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+  auto handleAdisReply = [&](GyroAdis& gyro) {
+    std::memcpy(&gyro.readerReply, &gyro.ownReply, sizeof(acs::Adis1650XReply));
+    *buffer = reinterpret_cast<uint8_t*>(&gyro.readerReply);
+    *size = sizeof(acs::Adis1650XReply);
+    return gyro.replyResult;
+  };
+  auto handleL3gReply = [&](GyroL3g& gyro) {
+    std::memcpy(&gyro.readerReply, &gyro.ownReply, sizeof(acs::GyroL3gReply));
+    *buffer = reinterpret_cast<uint8_t*>(&gyro.readerReply);
+    *size = sizeof(acs::GyroL3gReply);
+    return gyro.replyResult;
+  };
+  auto handleRm3100Reply = [&](MgmRm3100& mgm) {
+    std::memcpy(&mgm.readerReply, &mgm.ownReply, sizeof(acs::MgmRm3100Reply));
+    *buffer = reinterpret_cast<uint8_t*>(&mgm.readerReply);
+    *size = sizeof(acs::MgmRm3100Reply);
+    return mgm.replyResult;
+  };
+  auto handleLis3Reply = [&](MgmLis3& mgm) {
+    std::memcpy(&mgm.readerReply, &mgm.ownReply, sizeof(acs::MgmLis3Reply));
+    *buffer = reinterpret_cast<uint8_t*>(&mgm.readerReply);
+    *size = sizeof(acs::MgmLis3Reply);
+    return mgm.replyResult;
+  };
+  switch (spiCookie->getChipSelectPin()) {
+    case (gpioIds::MGM_0_LIS3_CS): {
+      return handleLis3Reply(mgm0Lis3);
+    }
+    case (gpioIds::MGM_1_RM3100_CS): {
+      return handleRm3100Reply(mgm1Rm3100);
+    }
+    case (gpioIds::MGM_2_LIS3_CS): {
+      return handleLis3Reply(mgm2Lis3);
+    }
+    case (gpioIds::MGM_3_RM3100_CS): {
+      return handleRm3100Reply(mgm3Rm3100);
+    }
+    case (gpioIds::GYRO_0_ADIS_CS): {
+      return handleAdisReply(gyro0Adis);
+    }
+    case (gpioIds::GYRO_2_ADIS_CS): {
+      return handleAdisReply(gyro2Adis);
+    }
+    case (gpioIds::GYRO_1_L3G_CS): {
+      return handleL3gReply(gyro1L3g);
+    }
+    case (gpioIds::GYRO_3_L3G_CS): {
+      return handleL3gReply(gyro3L3g);
+    }
+  }
+  return returnvalue::OK;
+}
+
+void AcsBoardPolling::gyroL3gHandler(GyroL3g& l3g) {
+  ReturnValue_t result;
+  acs::SimpleSensorMode mode = acs::SimpleSensorMode::OFF;
+  bool gyroPerformStartup = false;
+  {
+    MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+    mode = l3g.mode;
+    gyroPerformStartup = l3g.performStartup;
+  }
+  if (mode == acs::SimpleSensorMode::NORMAL) {
+    if (gyroPerformStartup) {
+      cmdBuf[0] = l3gd20h::CTRL_REG_1 | l3gd20h::AUTO_INCREMENT_MASK;
+      std::memcpy(cmdBuf.data() + 1, l3g.sensorCfg, 5);
+      result = spiComIF.sendMessage(l3g.cookie, cmdBuf.data(), 6);
+      if (result != returnvalue::OK) {
+        l3g.replyResult = returnvalue::OK;
+      }
+      // Ignore useless reply and red config
+      cmdBuf[0] = l3gd20h::CTRL_REG_1 | l3gd20h::AUTO_INCREMENT_MASK | l3gd20h::READ_MASK;
+      std::memset(cmdBuf.data() + 1, 0, 5);
+      result = spiComIF.sendMessage(l3g.cookie, cmdBuf.data(), 6);
+      if (result != returnvalue::OK) {
+        l3g.replyResult = returnvalue::OK;
+      }
+      result = spiComIF.readReceivedMessage(l3g.cookie, &rawReply, &dummy);
+      if (result != returnvalue::OK) {
+        l3g.replyResult = returnvalue::OK;
+      }
+      MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+      // Cross check configuration as verification that communication is working
+      for (uint8_t idx = 0; idx < 5; idx++) {
+        if (rawReply[idx + 1] != l3g.sensorCfg[idx]) {
+          sif::warning << "AcsBoardPolling: l3g config check missmatch" << std::endl;
+          l3g.replyResult = returnvalue::FAILED;
+          return;
+        }
+      }
+      l3g.performStartup = false;
+      l3g.ownReply.cfgWasSet = true;
+      l3g.ownReply.sensitivity = l3gd20h::ctrlReg4ToSensitivity(l3g.sensorCfg[3]);
+    }
+    cmdBuf[0] = l3gd20h::READ_START | l3gd20h::AUTO_INCREMENT_MASK | l3gd20h::READ_MASK;
+    std::memset(cmdBuf.data() + 1, 0, l3gd20h::READ_LEN);
+    result = spiComIF.sendMessage(l3g.cookie, cmdBuf.data(), l3gd20h::READ_LEN + 1);
+    if (result != returnvalue::OK) {
+      l3g.replyResult = returnvalue::FAILED;
+      return;
+    }
+    result = spiComIF.readReceivedMessage(l3g.cookie, &rawReply, &dummy);
+    if (result != returnvalue::OK) {
+      l3g.replyResult = returnvalue::FAILED;
+      return;
+    }
+    MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+    // The regular read function always returns the full sensor config as well. Use that
+    // to verify communications.
+    for (uint8_t idx = 0; idx < 5; idx++) {
+      if (rawReply[idx + 1] != l3g.sensorCfg[idx]) {
+        sif::warning << "AcsBoardPolling: l3g config check missmatch" << std::endl;
+        l3g.replyResult = returnvalue::FAILED;
+        return;
+      }
+    }
+    l3g.ownReply.statusReg = rawReply[l3gd20h::STATUS_IDX];
+    l3g.ownReply.angVelocities[0] = (rawReply[l3gd20h::OUT_X_H] << 8) | rawReply[l3gd20h::OUT_X_L];
+    l3g.ownReply.angVelocities[1] = (rawReply[l3gd20h::OUT_Y_H] << 8) | rawReply[l3gd20h::OUT_Y_L];
+    l3g.ownReply.angVelocities[2] = (rawReply[l3gd20h::OUT_Z_H] << 8) | rawReply[l3gd20h::OUT_Z_L];
+    l3g.ownReply.tempOffsetRaw = rawReply[l3gd20h::TEMPERATURE_IDX];
+  }
+}
+
+ReturnValue_t AcsBoardPolling::readAdisCfg(SpiCookie& cookie, size_t transferLen) {
+  ReturnValue_t result = returnvalue::OK;
+  int retval = 0;
+  // Prepare transfer
+  int fileDescriptor = 0;
+  std::string device = spiComIF.getSpiDev();
+  UnixFileGuard fileHelper(device, fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
+  if (fileHelper.getOpenResult() != returnvalue::OK) {
+    return SpiComIF::OPENING_FILE_FAILED;
+  }
+  spi::SpiModes spiMode = spi::SpiModes::MODE_0;
+  uint32_t spiSpeed = 0;
+  cookie.getSpiParameters(spiMode, spiSpeed, nullptr);
+  spiComIF.setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
+  cookie.assignWriteBuffer(cmdBuf.data());
+  cookie.setTransferSize(2);
+
+  gpioId_t gpioId = cookie.getChipSelectPin();
+  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
+  uint32_t timeoutMs = 0;
+  MutexIF* mutex = spiComIF.getCsMutex();
+  cookie.getMutexParams(timeoutType, timeoutMs);
+  if (mutex == nullptr) {
+    sif::warning << "GyroADIS16507Handler::spiSendCallback: "
+                    "Mutex or GPIO interface invalid"
+                 << std::endl;
+    return returnvalue::FAILED;
+  }
+
+  size_t idx = 0;
+  spi_ioc_transfer* transferStruct = cookie.getTransferStructHandle();
+  uint64_t origTx = transferStruct->tx_buf;
+  uint64_t origRx = transferStruct->rx_buf;
+  while (idx < transferLen) {
+    result = mutex->lockMutex(timeoutType, timeoutMs);
+    if (result != returnvalue::OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error << "AcsBoardPolling: Failed to lock mutex" << std::endl;
+#endif
+      return result;
+    }
+    // Pull SPI CS low. For now, no support for active high given
+    if (gpioId != gpio::NO_GPIO) {
+      gpioIF.pullLow(gpioId);
+    }
+
+    // Execute transfer
+    // Initiate a full duplex SPI transfer.
+    retval = ioctl(fileDescriptor, SPI_IOC_MESSAGE(1), cookie.getTransferStructHandle());
+    if (retval < 0) {
+      utility::handleIoctlError("SpiComIF::sendMessage: ioctl error.");
+      result = SpiComIF::FULL_DUPLEX_TRANSFER_FAILED;
+    }
+#if FSFW_HAL_SPI_WIRETAPPING == 1
+    comIf->performSpiWiretapping(cookie);
+#endif /* FSFW_LINUX_SPI_WIRETAPPING == 1 */
+
+    if (gpioId != gpio::NO_GPIO) {
+      gpioIF.pullHigh(gpioId);
+    }
+    mutex->unlockMutex();
+
+    idx += 2;
+    transferStruct->tx_buf += 2;
+    transferStruct->rx_buf += 2;
+    if (idx < transferLen) {
+      usleep(adis1650x::STALL_TIME_MICROSECONDS);
+    }
+  }
+  transferStruct->tx_buf = origTx;
+  transferStruct->rx_buf = origRx;
+  cookie.setTransferSize(transferLen);
+  return returnvalue::OK;
+}
+
+void AcsBoardPolling::gyroAdisHandler(GyroAdis& gyro) {
+  ReturnValue_t result;
+  acs::SimpleSensorMode mode = acs::SimpleSensorMode::OFF;
+  bool cdHasTimedOut = false;
+  bool mustPerformStartup = false;
+  {
+    MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+    mode = gyro.mode;
+    cdHasTimedOut = gyro.countdown.hasTimedOut();
+    mustPerformStartup = gyro.performStartup;
+  }
+  if (mode == acs::SimpleSensorMode::OFF) {
+    return;
+  }
+  if (not cdHasTimedOut) {
+    return;
+  }
+  if (mustPerformStartup) {
+    uint8_t regList[6];
+    // Read configuration
+    regList[0] = adis1650x::DIAG_STAT_REG;
+    regList[1] = adis1650x::FILTER_CTRL_REG;
+    regList[2] = adis1650x::RANG_MDL_REG;
+    regList[3] = adis1650x::MSC_CTRL_REG;
+    regList[4] = adis1650x::DEC_RATE_REG;
+    regList[5] = adis1650x::PROD_ID_REG;
+    size_t transferLen =
+        adis1650x::prepareReadCommand(regList, sizeof(regList), cmdBuf.data(), cmdBuf.size());
+    result = readAdisCfg(*gyro.cookie, transferLen);
+    if (result != returnvalue::OK) {
+      gyro.replyResult = result;
+      return;
+    }
+    result = spiComIF.readReceivedMessage(gyro.cookie, &rawReply, &dummy);
+    if (result != returnvalue::OK or rawReply == nullptr) {
+      gyro.replyResult = result;
+      return;
+    }
+    uint16_t prodId = (rawReply[12] << 8) | rawReply[13];
+    if (((gyro.type == adis1650x::Type::ADIS16505) and (prodId != adis1650x::PROD_ID_16505)) or
+        ((gyro.type == adis1650x::Type::ADIS16507) and (prodId != adis1650x::PROD_ID_16507))) {
+      sif::warning << "AcsPollingTask: Invalid  ADIS product ID " << prodId << std::endl;
+      gyro.replyResult = returnvalue::FAILED;
+      return;
+    }
+    MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+    gyro.ownReply.cfgWasSet = true;
+    gyro.ownReply.cfg.diagStat = (rawReply[2] << 8) | rawReply[3];
+    gyro.ownReply.cfg.filterSetting = (rawReply[4] << 8) | rawReply[5];
+    gyro.ownReply.cfg.rangMdl = (rawReply[6] << 8) | rawReply[7];
+    gyro.ownReply.cfg.mscCtrlReg = (rawReply[8] << 8) | rawReply[9];
+    gyro.ownReply.cfg.decRateReg = (rawReply[10] << 8) | rawReply[11];
+    gyro.ownReply.cfg.prodId = prodId;
+    gyro.ownReply.data.sensitivity = adis1650x::rangMdlToSensitivity(gyro.ownReply.cfg.rangMdl);
+    gyro.performStartup = false;
+  }
+  // Read regular registers
+  std::memcpy(cmdBuf.data(), adis1650x::BURST_READ_ENABLE.data(),
+              adis1650x::BURST_READ_ENABLE.size());
+  std::memset(cmdBuf.data() + 2, 0, 10 * 2);
+  result = spiComIF.sendMessage(gyro.cookie, cmdBuf.data(), adis1650x::SENSOR_READOUT_SIZE);
+  if (result != returnvalue::OK) {
+    gyro.replyResult = returnvalue::FAILED;
+    return;
+  }
+  result = spiComIF.readReceivedMessage(gyro.cookie, &rawReply, &dummy);
+  if (result != returnvalue::OK or rawReply == nullptr) {
+    gyro.replyResult = returnvalue::FAILED;
+    return;
+  }
+  uint16_t checksum = (rawReply[20] << 8) | rawReply[21];
+
+  // Now verify the read checksum with the expected checksum according to datasheet p. 20
+  uint16_t calcChecksum = 0;
+  for (size_t idx = 2; idx < 20; idx++) {
+    calcChecksum += rawReply[idx];
+  }
+  if (checksum != calcChecksum) {
+    sif::warning << "AcsPollingTask: Invalid ADIS reply checksum" << std::endl;
+    gyro.replyResult = returnvalue::FAILED;
+    return;
+  }
+
+  auto burstMode = adis1650x::burstModeFromMscCtrl(gyro.ownReply.cfg.mscCtrlReg);
+  if (burstMode != adis1650x::BurstModes::BURST_16_BURST_SEL_0) {
+    sif::error << "GyroADIS1650XHandler::interpretDeviceReply: Analysis for select burst mode"
+                  " not implemented!"
+               << std::endl;
+    gyro.replyResult = returnvalue::FAILED;
+    return;
+  }
+
+  MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+  gyro.ownReply.dataWasSet = true;
+  gyro.ownReply.cfg.diagStat = rawReply[2] << 8 | rawReply[3];
+  gyro.ownReply.data.angVelocities[0] = (rawReply[4] << 8) | rawReply[5];
+  gyro.ownReply.data.angVelocities[1] = (rawReply[6] << 8) | rawReply[7];
+  gyro.ownReply.data.angVelocities[2] = (rawReply[8] << 8) | rawReply[9];
+
+  gyro.ownReply.data.accelerations[0] = (rawReply[10] << 8) | rawReply[11];
+  gyro.ownReply.data.accelerations[1] = (rawReply[12] << 8) | rawReply[13];
+  gyro.ownReply.data.accelerations[2] = (rawReply[14] << 8) | rawReply[15];
+
+  gyro.ownReply.data.temperatureRaw = (rawReply[16] << 8) | rawReply[17];
+}
+
+void AcsBoardPolling::mgmLis3Handler(MgmLis3& mgm) {
+  ReturnValue_t result;
+  acs::SimpleSensorMode mode = acs::SimpleSensorMode::OFF;
+  bool mustPerformStartup = false;
+  {
+    MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+    mode = mgm.mode;
+    mustPerformStartup = mgm.performStartup;
+  }
+  if (mode == acs::SimpleSensorMode::NORMAL) {
+    if (mustPerformStartup) {
+      // To check valid communication, read back identification
+      // register which should always be the same value.
+      cmdBuf[0] = mgmLis3::readCommand(mgmLis3::IDENTIFY_DEVICE_REG_ADDR);
+      cmdBuf[1] = 0x00;
+      result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 2);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      result = spiComIF.readReceivedMessage(mgm.cookie, &rawReply, &dummy);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      if (rawReply[1] != mgmLis3::DEVICE_ID) {
+        sif::error << "AcsPollingTask: invalid MGM lis3 device ID" << std::endl;
+        mgm.replyResult = result;
+        return;
+      }
+      mgm.cfg[0] = mgmLis3::CTRL_REG1_DEFAULT;
+      mgm.cfg[1] = mgmLis3::CTRL_REG2_DEFAULT;
+      mgm.cfg[2] = mgmLis3::CTRL_REG3_DEFAULT;
+      mgm.cfg[3] = mgmLis3::CTRL_REG4_DEFAULT;
+      mgm.cfg[4] = mgmLis3::CTRL_REG5_DEFAULT;
+      cmdBuf[0] = mgmLis3::writeCommand(mgmLis3::CTRL_REG1, true);
+      std::memcpy(cmdBuf.data() + 1, mgm.cfg, 5);
+      result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 6);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      // Done here. We can always read back config and data during periodic handling
+      mgm.performStartup = false;
+    }
+    cmdBuf[0] = mgmLis3::readCommand(mgmLis3::CTRL_REG1, true);
+    std::memset(cmdBuf.data() + 1, 0, mgmLis3::NR_OF_DATA_AND_CFG_REGISTERS);
+    result =
+        spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), mgmLis3::NR_OF_DATA_AND_CFG_REGISTERS + 1);
+    if (result != returnvalue::OK) {
+      mgm.replyResult = result;
+      return;
+    }
+    result = spiComIF.readReceivedMessage(mgm.cookie, &rawReply, &dummy);
+    if (result != returnvalue::OK) {
+      mgm.replyResult = result;
+      return;
+    }
+    // Verify communication by re-checking config
+    if (rawReply[1] != mgm.cfg[0] or rawReply[2] != mgm.cfg[1] or rawReply[3] != mgm.cfg[2] or
+        rawReply[4] != mgm.cfg[3] or rawReply[5] != mgm.cfg[4]) {
+      mgm.replyResult = result;
+      return;
+    }
+    {
+      MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+      mgm.ownReply.dataWasSet = true;
+      mgm.ownReply.sensitivity = mgmLis3::getSensitivityFactor(mgmLis3::getSensitivity(mgm.cfg[1]));
+      mgm.ownReply.mgmValuesRaw[0] =
+          (rawReply[mgmLis3::X_HIGHBYTE_IDX] << 8) | rawReply[mgmLis3::X_LOWBYTE_IDX];
+      mgm.ownReply.mgmValuesRaw[1] =
+          (rawReply[mgmLis3::Y_HIGHBYTE_IDX] << 8) | rawReply[mgmLis3::Y_LOWBYTE_IDX];
+      mgm.ownReply.mgmValuesRaw[2] =
+          (rawReply[mgmLis3::Z_HIGHBYTE_IDX] << 8) | rawReply[mgmLis3::Z_LOWBYTE_IDX];
+    }
+    // Read tempetature
+    cmdBuf[0] = mgmLis3::readCommand(mgmLis3::TEMP_LOWBYTE, true);
+    result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 3);
+    if (result != returnvalue::OK) {
+      mgm.replyResult = result;
+      return;
+    }
+    result = spiComIF.readReceivedMessage(mgm.cookie, &rawReply, &dummy);
+    if (result != returnvalue::OK) {
+      mgm.replyResult = result;
+      return;
+    }
+    MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+    mgm.ownReply.temperatureWasSet = true;
+    mgm.ownReply.temperatureRaw = (rawReply[2] << 8) | rawReply[1];
+  }
+}
+
+void AcsBoardPolling::mgmRm3100Handler(MgmRm3100& mgm) {
+  ReturnValue_t result;
+  acs::SimpleSensorMode mode = acs::SimpleSensorMode::OFF;
+  bool mustPerformStartup = false;
+  {
+    MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+    mode = mgm.mode;
+    mustPerformStartup = mgm.performStartup;
+  }
+  if (mode == acs::SimpleSensorMode::NORMAL) {
+    if (mustPerformStartup) {
+      // Configure CMM first
+      cmdBuf[0] = mgmRm3100::CMM_REGISTER;
+      cmdBuf[1] = mgmRm3100::CMM_VALUE;
+      result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 2);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      // Read back register
+      cmdBuf[0] = mgmRm3100::CMM_REGISTER | mgmRm3100::READ_MASK;
+      cmdBuf[1] = 0;
+      result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 2);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      result = spiComIF.readReceivedMessage(mgm.cookie, &rawReply, &dummy);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      if (rawReply[1] != mgmRm3100::CMM_VALUE) {
+        sif::error << "AcsBoardPolling: MGM RM3100 read back CMM invalid" << std::endl;
+        mgm.replyResult = result;
+        return;
+      }
+      // Configure TMRC register
+      cmdBuf[0] = mgmRm3100::TMRC_REGISTER;
+      // hardcoded for now
+      cmdBuf[1] = mgm.tmrcValue;
+      result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 2);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      // Read back and verify value
+      cmdBuf[0] = mgmRm3100::TMRC_REGISTER | mgmRm3100::READ_MASK;
+      cmdBuf[1] = 0;
+      result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 2);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      result = spiComIF.readReceivedMessage(mgm.cookie, &rawReply, &dummy);
+      if (result != OK) {
+        mgm.replyResult = result;
+        return;
+      }
+      if (rawReply[1] != mgm.tmrcValue) {
+        sif::error << "AcsBoardPolling: MGM RM3100 read back TMRC invalid" << std::endl;
+        mgm.replyResult = result;
+        return;
+      }
+      mgm.performStartup = false;
+    }
+    // Regular read operation
+    cmdBuf[0] = mgmRm3100::MEASUREMENT_REG_START | mgmRm3100::READ_MASK;
+    std::memset(cmdBuf.data() + 1, 0, 9);
+    result = spiComIF.sendMessage(mgm.cookie, cmdBuf.data(), 10);
+    if (result != OK) {
+      mgm.replyResult = result;
+      return;
+    }
+    result = spiComIF.readReceivedMessage(mgm.cookie, &rawReply, &dummy);
+    if (result != OK) {
+      mgm.replyResult = result;
+      return;
+    }
+    MutexGuard mg(ipcLock, LOCK_TYPE, LOCK_TIMEOUT, LOCK_CTX);
+    for (uint8_t idx = 0; idx < 3; idx++) {
+      // Hardcoded, but note that the gain depends on the cycle count
+      // value which is configurable!
+      mgm.ownReply.scaleFactors[idx] = 1.0 / mgmRm3100::DEFAULT_GAIN;
+    }
+    mgm.ownReply.dataWasRead = true;
+    // Bitshift trickery to account for 24 bit signed value.
+    mgm.ownReply.mgmValuesRaw[0] =
+        ((rawReply[1] << 24) | (rawReply[2] << 16) | (rawReply[3] << 8)) >> 8;
+    mgm.ownReply.mgmValuesRaw[1] =
+        ((rawReply[4] << 24) | (rawReply[5] << 16) | (rawReply[6] << 8)) >> 8;
+    mgm.ownReply.mgmValuesRaw[2] =
+        ((rawReply[7] << 24) | (rawReply[8] << 16) | (rawReply[9] << 8)) >> 8;
+  }
+}

linux/acs/AcsBoardPolling.h

@@ -0,0 +1,91 @@
+#ifndef LINUX_DEVICES_ACSBOARDPOLLING_H_
+#define LINUX_DEVICES_ACSBOARDPOLLING_H_
+
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+#include <fsfw/tasks/SemaphoreIF.h>
+#include <fsfw_hal/devicehandlers/devicedefinitions/mgmRm3100Helpers.h>
+#include <fsfw_hal/linux/spi/SpiComIF.h>
+#include <mission/acs/acsBoardPolling.h>
+#include <mission/acs/gyroAdisHelpers.h>
+
+class AcsBoardPolling : public SystemObject,
+                        public ExecutableObjectIF,
+                        public DeviceCommunicationIF {
+ public:
+  AcsBoardPolling(object_id_t objectId, SpiComIF& lowLevelComIF, GpioIF& gpioIF);
+
+  ReturnValue_t performOperation(uint8_t operationCode) override;
+  ReturnValue_t initialize() override;
+
+ private:
+  enum class InternalState { IDLE, IS_BUSY } state = InternalState::IDLE;
+  MutexIF* ipcLock;
+  static constexpr MutexIF::TimeoutType LOCK_TYPE = MutexIF::TimeoutType::WAITING;
+  static constexpr uint32_t LOCK_TIMEOUT = 20;
+  static constexpr char LOCK_CTX[] = "AcsBoardPolling";
+  SemaphoreIF* semaphore;
+  std::array<uint8_t, 32> cmdBuf;
+
+  struct DevBase {
+    SpiCookie* cookie = nullptr;
+    bool performStartup = false;
+    acs::SimpleSensorMode mode = acs::SimpleSensorMode::OFF;
+    ReturnValue_t replyResult = returnvalue::OK;
+  };
+
+  struct GyroAdis : public DevBase {
+    adis1650x::Type type;
+    Countdown countdown;
+    acs::Adis1650XReply ownReply;
+    acs::Adis1650XReply readerReply;
+  };
+  GyroAdis gyro0Adis{};
+  GyroAdis gyro2Adis{};
+
+  struct GyroL3g : public DevBase {
+    uint8_t sensorCfg[5];
+    acs::GyroL3gReply ownReply;
+    acs::GyroL3gReply readerReply;
+  };
+  GyroL3g gyro1L3g{};
+  GyroL3g gyro3L3g{};
+
+  struct MgmRm3100 : public DevBase {
+    uint8_t tmrcValue = mgmRm3100::TMRC_DEFAULT_37HZ_VALUE;
+    acs::MgmRm3100Reply ownReply;
+    acs::MgmRm3100Reply readerReply;
+  };
+  MgmRm3100 mgm1Rm3100;
+  MgmRm3100 mgm3Rm3100;
+
+  struct MgmLis3 : public DevBase {
+    uint8_t cfg[5]{};
+    acs::MgmLis3Reply ownReply;
+    acs::MgmLis3Reply readerReply;
+  };
+  MgmLis3 mgm0Lis3;
+  MgmLis3 mgm2Lis3;
+
+  uint8_t* rawReply = nullptr;
+  size_t dummy = 0;
+
+  SpiComIF& spiComIF;
+  GpioIF& gpioIF;
+
+  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;
+
+  void gyroL3gHandler(GyroL3g& l3g);
+  void gyroAdisHandler(GyroAdis& gyro);
+  void mgmLis3Handler(MgmLis3& mgm);
+  void mgmRm3100Handler(MgmRm3100& mgm);
+  // Special readout: 16us stall time between small 2 byte transfers.
+  ReturnValue_t readAdisCfg(SpiCookie& spiCookie, size_t transferLen);
+};
+
+#endif /* LINUX_DEVICES_ACSBOARDPOLLING_H_ */

linux/acs/CMakeLists.txt

@@ -0,0 +1,7 @@
+target_sources(${OBSW_NAME} PUBLIC AcsBoardPolling.cpp ImtqPollingTask.cpp
+                                   RwPollingTask.cpp SusPolling.cpp)
+
+# Dependency on proprietary library
+if(TGT_BSP MATCHES "arm/q7s")
+  add_subdirectory(startracker)
+endif()

linux/acs/ImtqPollingTask.cpp

@@ -0,0 +1,486 @@
+#include "ImtqPollingTask.h"
+
+#include <fcntl.h>
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
+#include <fsfw_hal/linux/UnixFileGuard.h>
+#include <linux/i2c-dev.h>
+#include <sys/ioctl.h>
+
+#include "fsfw/FSFW.h"
+
+ImtqPollingTask::ImtqPollingTask(object_id_t imtqPollingTask, std::atomic_uint16_t& i2cFatalErrors)
+    : SystemObject(imtqPollingTask), i2cFatalErrors(i2cFatalErrors) {
+  semaphore = SemaphoreFactory::instance()->createBinarySemaphore();
+  semaphore->acquire();
+  ipcLock = MutexFactory::instance()->createMutex();
+  bufLock = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t ImtqPollingTask::performOperation(uint8_t operationCode) {
+  while (true) {
+    ipcLock->lockMutex();
+    state = InternalState::IDLE;
+    ipcLock->unlockMutex();
+    semaphore->acquire();
+
+    comStatus = returnvalue::OK;
+    // Stopwatch watch;
+    switch (currentRequest) {
+      case imtq::RequestType::MEASURE_NO_ACTUATION: {
+        // Measured to take 24 ms for debug and release builds.
+        // Stopwatch watch;
+        handleMeasureStep();
+        break;
+      }
+      case imtq::RequestType::ACTUATE: {
+        handleActuateStep();
+        break;
+      }
+      default: {
+        break;
+      }
+    };
+  }
+  return returnvalue::OK;
+}
+
+void ImtqPollingTask::handleMeasureStep() {
+  size_t replyLen = 0;
+  uint8_t* replyPtr;
+  ImtqRepliesDefault replies(replyBuf.data());
+  // If some startup handling is added later, set configured after it was done once.
+  replies.setConfigured();
+
+  // Can be used later to verify correct timing (e.g. all data has been read)
+  clearReadFlagsDefault(replies);
+  auto i2cCmdExecMeasure = [&](imtq::CC::CC cc) {
+    ccToReplyPtrMeasure(replies, cc, &replyPtr, replyLen);
+    return i2cCmdExecDefault(cc, replyPtr, replyLen, imtq::MGM_MEASUREMENT_LOW_LEVEL_ERROR);
+  };
+
+  cmdLen = 1;
+  cmdBuf[0] = imtq::CC::GET_SYSTEM_STATE;
+  if (i2cCmdExecMeasure(imtq::CC::GET_SYSTEM_STATE) != returnvalue::OK) {
+    return;
+  }
+
+  ignoreNextActuateRequest =
+      (replies.getSystemState()[2] == static_cast<uint8_t>(imtq::mode::SELF_TEST));
+  if (ignoreNextActuateRequest) {
+    // Do not command anything until self-test is done.
+    return;
+  }
+
+  if (specialRequest != imtq::SpecialRequest::NONE) {
+    auto executeSelfTest = [&](imtq::selfTest::Axis axis) {
+      cmdBuf[0] = imtq::CC::SELF_TEST_CMD;
+      cmdBuf[1] = axis;
+      return i2cCmdExecMeasure(imtq::CC::SELF_TEST_CMD);
+    };
+    // If a self-test is already ongoing, ignore the request.
+    if (replies.getSystemState()[2] != static_cast<uint8_t>(imtq::mode::SELF_TEST)) {
+      switch (specialRequest) {
+        case (imtq::SpecialRequest::DO_SELF_TEST_POS_X): {
+          executeSelfTest(imtq::selfTest::Axis::X_POSITIVE);
+          break;
+        }
+        case (imtq::SpecialRequest::DO_SELF_TEST_NEG_X): {
+          executeSelfTest(imtq::selfTest::Axis::X_NEGATIVE);
+          break;
+        }
+        case (imtq::SpecialRequest::DO_SELF_TEST_POS_Y): {
+          executeSelfTest(imtq::selfTest::Axis::Y_POSITIVE);
+          break;
+        }
+        case (imtq::SpecialRequest::DO_SELF_TEST_NEG_Y): {
+          executeSelfTest(imtq::selfTest::Axis::Y_NEGATIVE);
+          break;
+        }
+        case (imtq::SpecialRequest::DO_SELF_TEST_POS_Z): {
+          executeSelfTest(imtq::selfTest::Axis::Z_POSITIVE);
+          break;
+        }
+        case (imtq::SpecialRequest::DO_SELF_TEST_NEG_Z): {
+          executeSelfTest(imtq::selfTest::Axis::Z_NEGATIVE);
+          break;
+        }
+        case (imtq::SpecialRequest::GET_SELF_TEST_RESULT): {
+          cmdBuf[0] = imtq::CC::GET_SELF_TEST_RESULT;
+          i2cCmdExecMeasure(imtq::CC::GET_SELF_TEST_RESULT);
+          break;
+        }
+        default: {
+          // Should never happen
+          break;
+        }
+      }
+      // We are done. Only request self test or results here.
+      return;
+    }
+  }
+
+  // The I2C IP core on EIVE sometimes glitches out. Send start MTM measurement twice.
+  cmdBuf[0] = imtq::CC::START_MTM_MEASUREMENT;
+  if (i2cCmdExecMeasure(imtq::CC::START_MTM_MEASUREMENT) != returnvalue::OK) {
+    return;
+  }
+  cmdBuf[0] = imtq::CC::START_MTM_MEASUREMENT;
+  if (i2cCmdExecMeasure(imtq::CC::START_MTM_MEASUREMENT) != returnvalue::OK) {
+    return;
+  }
+  // Takes a bit of time to take measurements. Subtract a bit because of the delay of previous
+  // commands.
+  TaskFactory::delayTask(currentIntegrationTimeMs + MGM_READ_BUFFER_TIME_MS);
+
+  cmdBuf[0] = imtq::CC::GET_RAW_MTM_MEASUREMENT;
+  if (i2cCmdExecMeasure(imtq::CC::GET_RAW_MTM_MEASUREMENT) != returnvalue::OK) {
+    return;
+  }
+  bool mgmMeasurementTooOld = false;
+  // See p.39 of the iMTQ user manual. If the NEW bit of the STAT bitfield is not set, we probably
+  // have old data. Which can be really bad for ACS. And everything.
+  if ((replyPtr[2] >> 7) == 0) {
+    replyPtr[0] = false;
+    mgmMeasurementTooOld = true;
+  }
+
+  cmdBuf[0] = imtq::CC::GET_ENG_HK_DATA;
+  if (i2cCmdExecMeasure(imtq::CC::GET_ENG_HK_DATA) != returnvalue::OK) {
+    return;
+  }
+
+  cmdBuf[0] = imtq::CC::GET_CAL_MTM_MEASUREMENT;
+  if (i2cCmdExecMeasure(imtq::CC::GET_CAL_MTM_MEASUREMENT) != returnvalue::OK) {
+    return;
+  }
+  if (mgmMeasurementTooOld) {
+    sif::error << "IMTQ: MGM measurement too old" << std::endl;
+  }
+  return;
+}
+
+void ImtqPollingTask::handleActuateStep() {
+  uint8_t* replyPtr = nullptr;
+  size_t replyLen = 0;
+  // No point when self-test mode is active.
+  if (ignoreNextActuateRequest) {
+    return;
+  }
+  ImtqRepliesWithTorque replies(replyBufActuation.data());
+  // Can be used later to verify correct timing (e.g. all data has been read)
+  clearReadFlagsWithTorque(replies);
+  auto i2cCmdExecActuate = [&](imtq::CC::CC cc) {
+    ccToReplyPtrActuate(replies, cc, &replyPtr, replyLen);
+    return i2cCmdExecDefault(cc, replyPtr, replyLen, imtq::ACTUATE_CMD_LOW_LEVEL_ERROR);
+  };
+  buildDipoleCommand();
+  if (i2cCmdExecActuate(imtq::CC::START_ACTUATION_DIPOLE) != returnvalue::OK) {
+    return;
+  }
+
+  TaskFactory::delayTask(10);
+
+  cmdLen = 1;
+  // The I2C IP core on EIVE sometimes glitches out. Send start MTM measurement twice.
+  cmdBuf[0] = imtq::CC::START_MTM_MEASUREMENT;
+  if (i2cCmdExecActuate(imtq::CC::START_MTM_MEASUREMENT) != returnvalue::OK) {
+    return;
+  }
+  cmdBuf[0] = imtq::CC::START_MTM_MEASUREMENT;
+  if (i2cCmdExecActuate(imtq::CC::START_MTM_MEASUREMENT) != returnvalue::OK) {
+    return;
+  }
+
+  TaskFactory::delayTask(currentIntegrationTimeMs + MGM_READ_BUFFER_TIME_MS);
+
+  cmdBuf[0] = imtq::CC::GET_RAW_MTM_MEASUREMENT;
+  if (i2cCmdExecActuate(imtq::CC::GET_RAW_MTM_MEASUREMENT) != returnvalue::OK) {
+    return;
+  }
+  bool measurementWasTooOld = false;
+  // See p.39 of the iMTQ user manual. If the NEW bit of the STAT bitfield is not set, we probably
+  // have old data. Which can be really bad for ACS. And everything.
+  if ((replyPtr[2] >> 7) == 0) {
+    measurementWasTooOld = true;
+    replyPtr[0] = false;
+  }
+
+  cmdBuf[0] = imtq::CC::GET_ENG_HK_DATA;
+  if (i2cCmdExecActuate(imtq::CC::GET_ENG_HK_DATA) != returnvalue::OK) {
+    return;
+  }
+
+  if (measurementWasTooOld) {
+    sif::error << "IMTQ: MGM measurement too old" << std::endl;
+  }
+  return;
+}
+
+ReturnValue_t ImtqPollingTask::initialize() { return returnvalue::OK; }
+
+ReturnValue_t ImtqPollingTask::initializeInterface(CookieIF* cookie) {
+  i2cCookie = dynamic_cast<I2cCookie*>(cookie);
+  if (i2cCookie == nullptr) {
+    sif::error << "ImtqPollingTask::initializeInterface: Invalid I2C cookie" << std::endl;
+    return returnvalue::FAILED;
+  }
+  i2cDev = i2cCookie->getDeviceFile().c_str();
+  i2cAddr = i2cCookie->getAddress();
+  return returnvalue::OK;
+}
+
+ReturnValue_t ImtqPollingTask::sendMessage(CookieIF* cookie, const uint8_t* sendData,
+                                           size_t sendLen) {
+  const auto* imtqReq = reinterpret_cast<const imtq::Request*>(sendData);
+  {
+    MutexGuard mg(ipcLock);
+    if (imtqReq->request == imtq::RequestType::ACTUATE) {
+      std::memcpy(dipoles, imtqReq->dipoles, sizeof(dipoles));
+      torqueDuration = imtqReq->torqueDuration;
+    }
+    currentRequest = imtqReq->request;
+    specialRequest = imtqReq->specialRequest;
+    if (state != InternalState::IDLE) {
+      return returnvalue::FAILED;
+    }
+    state = InternalState::IS_BUSY;
+  }
+  semaphore->release();
+
+  return returnvalue::OK;
+}
+
+ReturnValue_t ImtqPollingTask::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
+
+ReturnValue_t ImtqPollingTask::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
+  return returnvalue::OK;
+}
+
+void ImtqPollingTask::ccToReplyPtrMeasure(ImtqRepliesDefault& replies, imtq::CC::CC cc,
+                                          uint8_t** replyBuf, size_t& replyLen) {
+  replyLen = imtq::getReplySize(cc);
+  switch (cc) {
+    case (imtq::CC::CC::GET_ENG_HK_DATA): {
+      *replyBuf = replies.engHk;
+      break;
+    }
+    case (imtq::CC::CC::SOFTWARE_RESET): {
+      *replyBuf = replies.swReset;
+      break;
+    }
+    case (imtq::CC::CC::GET_SYSTEM_STATE): {
+      *replyBuf = replies.systemState;
+      break;
+    }
+    case (imtq::CC::CC::START_MTM_MEASUREMENT): {
+      *replyBuf = replies.startMtmMeasurement;
+      break;
+    }
+    case (imtq::CC::CC::GET_RAW_MTM_MEASUREMENT): {
+      *replyBuf = replies.rawMgmMeasurement;
+      break;
+    }
+    case (imtq::CC::CC::GET_CAL_MTM_MEASUREMENT): {
+      *replyBuf = replies.calibMgmMeasurement;
+      break;
+    }
+    default: {
+      *replyBuf = replies.specialRequestReply;
+      break;
+    }
+  }
+}
+
+void ImtqPollingTask::ccToReplyPtrActuate(ImtqRepliesWithTorque& replies, imtq::CC::CC cc,
+                                          uint8_t** replyBuf, size_t& replyLen) {
+  replyLen = imtq::getReplySize(cc);
+  switch (cc) {
+    case (imtq::CC::CC::START_ACTUATION_DIPOLE): {
+      *replyBuf = replies.dipoleActuation;
+      break;
+    }
+    case (imtq::CC::CC::GET_ENG_HK_DATA): {
+      *replyBuf = replies.engHk;
+      break;
+    }
+    case (imtq::CC::CC::START_MTM_MEASUREMENT): {
+      *replyBuf = replies.startMtmMeasurement;
+      break;
+    }
+    case (imtq::CC::CC::GET_RAW_MTM_MEASUREMENT): {
+      *replyBuf = replies.rawMgmMeasurement;
+      break;
+    }
+    default: {
+      *replyBuf = nullptr;
+      replyLen = 0;
+      break;
+    }
+  }
+}
+size_t ImtqPollingTask::getExchangeBufLen(imtq::SpecialRequest specialRequest) {
+  size_t baseLen = ImtqRepliesDefault::BASE_LEN;
+  switch (specialRequest) {
+    case (imtq::SpecialRequest::NONE):
+    case (imtq::SpecialRequest::DO_SELF_TEST_POS_X):
+    case (imtq::SpecialRequest::DO_SELF_TEST_NEG_X):
+    case (imtq::SpecialRequest::DO_SELF_TEST_POS_Y):
+    case (imtq::SpecialRequest::DO_SELF_TEST_NEG_Y):
+    case (imtq::SpecialRequest::DO_SELF_TEST_POS_Z):
+    case (imtq::SpecialRequest::DO_SELF_TEST_NEG_Z): {
+      break;
+    }
+    case (imtq::SpecialRequest::GET_SELF_TEST_RESULT): {
+      baseLen += imtq::replySize::SELF_TEST_RESULTS;
+      break;
+    }
+  }
+  return baseLen;
+}
+
+void ImtqPollingTask::buildDipoleCommand() {
+  cmdBuf[0] = imtq::CC::CC::START_ACTUATION_DIPOLE;
+  uint8_t* serPtr = cmdBuf.data() + 1;
+  size_t serLen = 0;
+  for (uint8_t idx = 0; idx < 3; idx++) {
+    SerializeAdapter::serialize(&dipoles[idx], &serPtr, &serLen, cmdBuf.size(),
+                                SerializeIF::Endianness::LITTLE);
+  }
+  SerializeAdapter::serialize(&torqueDuration, &serPtr, &serLen, cmdBuf.size(),
+                              SerializeIF::Endianness::LITTLE);
+  // sif::debug << "Dipole X: " << dipoles[0] << std::endl;
+  // sif::debug << "Torqeu Dur: " << torqueDuration << std::endl;
+  cmdLen = 1 + serLen;
+}
+
+ReturnValue_t ImtqPollingTask::readReceivedMessage(CookieIF* cookie, uint8_t** buffer,
+                                                   size_t* size) {
+  imtq::RequestType currentRequest;
+  {
+    MutexGuard mg(ipcLock);
+    currentRequest = this->currentRequest;
+  }
+
+  size_t replyLen = 0;
+  MutexGuard mg(bufLock);
+  if (currentRequest == imtq::RequestType::MEASURE_NO_ACTUATION) {
+    replyLen = getExchangeBufLen(specialRequest);
+    memcpy(exchangeBuf.data(), replyBuf.data(), replyLen);
+  } else if (currentRequest == imtq::RequestType::ACTUATE) {
+    replyLen = ImtqRepliesWithTorque::BASE_LEN;
+    memcpy(exchangeBuf.data(), replyBufActuation.data(), replyLen);
+  } else {
+    *size = 0;
+  }
+  *buffer = exchangeBuf.data();
+  *size = replyLen;
+  return comStatus;
+}
+
+void ImtqPollingTask::clearReadFlagsDefault(ImtqRepliesDefault& replies) {
+  replies.calibMgmMeasurement[0] = false;
+  replies.rawMgmMeasurement[0] = false;
+  replies.systemState[0] = false;
+  replies.specialRequestReply[0] = false;
+  replies.engHk[0] = false;
+}
+
+ReturnValue_t ImtqPollingTask::i2cCmdExecDefault(imtq::CC::CC cc, uint8_t* replyPtr,
+                                                 size_t replyLen, ReturnValue_t comErrIfFails) {
+  ReturnValue_t res = performI2cFullRequest(replyPtr + 1, replyLen);
+  if (res != returnvalue::OK) {
+    sif::error << "IMTQ: I2C transaction for command 0x" << std::hex << std::setw(2) << cc
+               << " failed" << std::dec << std::endl;
+    comStatus = comErrIfFails;
+    return returnvalue::FAILED;
+  }
+  if (replyPtr[1] != cc) {
+    sif::warning << "IMTQ: Unexpected CC 0x" << std::hex << std::setw(2)
+                 << static_cast<int>(replyPtr[1]) << " for command 0x" << cc << std::dec
+                 << std::endl;
+    comStatus = comErrIfFails;
+    return returnvalue::FAILED;
+  }
+  replyPtr[0] = true;
+  return returnvalue::OK;
+}
+
+void ImtqPollingTask::clearReadFlagsWithTorque(ImtqRepliesWithTorque& replies) {
+  replies.dipoleActuation[0] = false;
+  replies.engHk[0] = false;
+  replies.rawMgmMeasurement[0] = false;
+  replies.startMtmMeasurement[0] = false;
+}
+
+ReturnValue_t ImtqPollingTask::performI2cFullRequest(uint8_t* reply, size_t replyLen) {
+  int fd = 0;
+  if (cmdLen == 0 or reply == nullptr) {
+    return returnvalue::FAILED;
+  }
+
+  {
+    UnixFileGuard fileHelper(i2cDev, fd, O_RDWR, "ImtqPollingTask::performI2cFullRequest");
+    if (fileHelper.getOpenResult() != returnvalue::OK) {
+      return fileHelper.getOpenResult();
+    }
+    if (ioctl(fd, I2C_SLAVE, i2cAddr) < 0) {
+      sif::warning << "Opening IMTQ slave device failed with code " << errno << ": "
+                   << strerror(errno) << std::endl;
+      if (errno == EBUSY) {
+        i2cFatalErrors++;
+      }
+    }
+
+    int written = write(fd, cmdBuf.data(), cmdLen);
+    if (written < 0) {
+      sif::error << "IMTQ: Failed to send with error code " << errno
+                 << ". Error description: " << strerror(errno) << std::endl;
+      // This is a weird issue which sometimes occurs on debug builds. All I2C buses are busy
+      // for all writes,
+      if (errno == EBUSY) {
+        i2cFatalErrors++;
+      }
+      return returnvalue::FAILED;
+    } else if (static_cast<size_t>(written) != cmdLen) {
+      sif::error << "IMTQ: Could not write all bytes" << std::endl;
+      return returnvalue::FAILED;
+    }
+  }
+#if FSFW_HAL_I2C_WIRETAPPING == 1
+  sif::info << "Sent I2C data to bus " << deviceFile << ":" << std::endl;
+  arrayprinter::print(sendData, sendLen);
+#endif
+
+  // wait 1 ms like specified in the datasheet. This is the time the IMTQ needs
+  // to prepare a reply.
+  usleep(1000);
+
+  {
+    UnixFileGuard fileHelper(i2cDev, fd, O_RDWR, "ImtqPollingTask::performI2cFullRequest");
+    if (fileHelper.getOpenResult() != returnvalue::OK) {
+      return fileHelper.getOpenResult();
+    }
+    if (ioctl(fd, I2C_SLAVE, i2cAddr) < 0) {
+      sif::warning << "Opening IMTQ slave device failed with code " << errno << ": "
+                   << strerror(errno) << std::endl;
+    }
+    MutexGuard mg(bufLock);
+    int readLen = read(fd, reply, replyLen);
+    if (readLen != static_cast<int>(replyLen)) {
+      if (readLen < 0) {
+        sif::warning << "IMTQ: Reading failed with error code " << errno << " | " << strerror(errno)
+                     << std::endl;
+      } else {
+        sif::warning << "IMTQ: Read only" << readLen << " from " << replyLen << " bytes"
+                     << std::endl;
+      }
+    }
+  }
+  if (reply[0] == 0xff or reply[1] == 0xff) {
+    sif::warning << "IMTQ: No reply available after 1 millisecond";
+    return NO_REPLY_AVAILABLE;
+  }
+  return returnvalue::OK;
+}

linux/acs/ImtqPollingTask.h

@@ -0,0 +1,74 @@
+#ifndef LINUX_DEVICES_IMTQPOLLINGTASK_H_
+#define LINUX_DEVICES_IMTQPOLLINGTASK_H_
+
+#include <fsfw/tasks/SemaphoreIF.h>
+#include <fsfw_hal/linux/i2c/I2cCookie.h>
+
+#include <atomic>
+
+#include "fsfw/devicehandlers/DeviceCommunicationIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+#include "mission/acs/imtqHelpers.h"
+
+class ImtqPollingTask : public SystemObject,
+                        public ExecutableObjectIF,
+                        public DeviceCommunicationIF {
+ public:
+  ImtqPollingTask(object_id_t imtqPollingTask, std::atomic_uint16_t& i2cFatalErrors);
+
+  ReturnValue_t performOperation(uint8_t operationCode) override;
+  ReturnValue_t initialize() override;
+
+ private:
+  static constexpr ReturnValue_t NO_REPLY_AVAILABLE = returnvalue::makeCode(2, 0);
+
+  enum class InternalState { IDLE, IS_BUSY } state = InternalState::IDLE;
+  imtq::RequestType currentRequest = imtq::RequestType::MEASURE_NO_ACTUATION;
+
+  SemaphoreIF* semaphore;
+  ReturnValue_t comStatus = returnvalue::OK;
+  MutexIF* ipcLock;
+  MutexIF* bufLock;
+  std::atomic_uint16_t& i2cFatalErrors;
+  I2cCookie* i2cCookie = nullptr;
+  const char* i2cDev = nullptr;
+  address_t i2cAddr = 0;
+  uint32_t currentIntegrationTimeMs = 10;
+  // Required in addition to integration time, otherwise old data might be read.
+  static constexpr uint32_t MGM_READ_BUFFER_TIME_MS = 6;
+  bool ignoreNextActuateRequest = false;
+
+  imtq::SpecialRequest specialRequest = imtq::SpecialRequest::NONE;
+  int16_t dipoles[3] = {};
+  uint16_t torqueDuration = 0;
+
+  std::array<uint8_t, 32> cmdBuf;
+  std::array<uint8_t, 524> replyBuf;
+  std::array<uint8_t, 524> replyBufActuation;
+  std::array<uint8_t, 524> exchangeBuf;
+  size_t cmdLen = 0;
+
+  // DeviceCommunicationIF overrides
+  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;
+
+  void ccToReplyPtrMeasure(ImtqRepliesDefault& replies, imtq::CC::CC cc, uint8_t** replyBuf,
+                           size_t& replyLen);
+  void ccToReplyPtrActuate(ImtqRepliesWithTorque& replies, imtq::CC::CC cc, uint8_t** replyBuf,
+                           size_t& replyLen);
+  void clearReadFlagsDefault(ImtqRepliesDefault& replies);
+  void clearReadFlagsWithTorque(ImtqRepliesWithTorque& replies);
+  size_t getExchangeBufLen(imtq::SpecialRequest specialRequest);
+  void buildDipoleCommand();
+  void handleMeasureStep();
+  void handleActuateStep();
+  ReturnValue_t i2cCmdExecDefault(imtq::CC::CC cc, uint8_t* replyPtr, size_t replyLen,
+                                  ReturnValue_t comErrIfFails);
+  ReturnValue_t performI2cFullRequest(uint8_t* reply, size_t replyLen);
+};
+
+#endif /* LINUX_DEVICES_IMTQPOLLINGTASK_H_ */

linux/acs/RwPollingTask.cpp

@@ -0,0 +1,542 @@
+#include "RwPollingTask.h"
+
+#include <fcntl.h>
+#include <fsfw/globalfunctions/CRC.h>
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
+#include <fsfw_hal/common/spi/spiCommon.h>
+#include <fsfw_hal/linux/utility.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+#include "devConf.h"
+#include "mission/acs/rwHelpers.h"
+
+RwPollingTask::RwPollingTask(object_id_t objectId, const char* spiDev, GpioIF& gpioIF)
+    : SystemObject(objectId), spiDev(spiDev), gpioIF(gpioIF) {
+  semaphore = SemaphoreFactory::instance()->createBinarySemaphore();
+  semaphore->acquire();
+  ipcLock = MutexFactory::instance()->createMutex();
+  spiLock = MutexFactory::instance()->createMutex();
+}
+
+ReturnValue_t RwPollingTask::performOperation(uint8_t operationCode) {
+  for (unsigned i = 0; i < 4; i++) {
+    if (rwCookies[i] == nullptr) {
+      sif::error << "Invalid RW cookie at index" << i << std::endl;
+      return returnvalue::FAILED;
+    }
+  }
+  while (true) {
+    ipcLock->lockMutex();
+    state = InternalState::IDLE;
+    ipcLock->unlockMutex();
+    semaphore->acquire();
+    // This loop takes 50 ms on a debug build.
+    // Stopwatch watch;
+    TaskFactory::delayTask(5);
+    int fd = 0;
+    for (auto& skip : skipCommandingForRw) {
+      skip = false;
+    }
+    setAllReadFlagsFalse();
+    ReturnValue_t result = openSpi(O_RDWR, fd);
+    if (result != returnvalue::OK) {
+      continue;
+    }
+    for (unsigned idx = 0; idx < rwCookies.size(); idx++) {
+      if (rwCookies[idx]->specialRequest == rws::SpecialRwRequest::RESET_MCU) {
+        prepareSimpleCommand(rws::RESET_MCU);
+        // No point in commanding that specific RW for the cycle.
+        skipCommandingForRw[idx] = true;
+        writeOneRwCmd(idx, fd);
+      } else if (rwCookies[idx]->setSpeed) {
+        prepareSetSpeedCmd(idx);
+        if (writeOneRwCmd(idx, fd) != returnvalue::OK) {
+          continue;
+        }
+      }
+    }
+    closeSpi(fd);
+    if (readAllRws(rws::SET_SPEED) != returnvalue::OK) {
+      continue;
+    }
+    prepareSimpleCommand(rws::GET_LAST_RESET_STATUS);
+    if (writeAndReadAllRws(rws::GET_LAST_RESET_STATUS) != returnvalue::OK) {
+      continue;
+    }
+    prepareSimpleCommand(rws::GET_RW_STATUS);
+    if (writeAndReadAllRws(rws::GET_RW_STATUS) != returnvalue::OK) {
+      continue;
+    }
+    prepareSimpleCommand(rws::GET_TEMPERATURE);
+    if (writeAndReadAllRws(rws::GET_TEMPERATURE) != returnvalue::OK) {
+      continue;
+    }
+    prepareSimpleCommand(rws::CLEAR_LAST_RESET_STATUS);
+    if (writeAndReadAllRws(rws::CLEAR_LAST_RESET_STATUS) != returnvalue::OK) {
+      continue;
+    }
+    handleSpecialRequests();
+  }
+
+  return returnvalue::OK;
+}
+
+ReturnValue_t RwPollingTask::initialize() { return returnvalue::OK; }
+
+ReturnValue_t RwPollingTask::initializeInterface(CookieIF* cookie) {
+  // We don't need to set the speed because a SPI core is used, but the mode has to be set once
+  // correctly for all RWs
+  if (not modeAndSpeedWasSet) {
+    int fd = open(spiDev, O_RDWR);
+    if (fd < 0) {
+      sif::error << "could not open RW SPI bus" << std::endl;
+      return returnvalue::FAILED;
+    }
+    spi::SpiModes mode = spi::RW_MODE;
+    int retval = ioctl(fd, SPI_IOC_WR_MODE, reinterpret_cast<uint8_t*>(&mode));
+    if (retval != 0) {
+      utility::handleIoctlError("SpiComIF::setSpiSpeedAndMode: Setting SPI mode failed");
+    }
+
+    retval = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ, &spi::RW_SPEED);
+    if (retval != 0) {
+      utility::handleIoctlError("SpiComIF::setSpiSpeedAndMode: Setting SPI speed failed");
+    }
+    close(fd);
+    modeAndSpeedWasSet = true;
+  }
+
+  auto* rwCookie = dynamic_cast<RwCookie*>(cookie);
+  if (rwCookie == nullptr) {
+    sif::error << "RwPollingTask::initializeInterface: Wrong cookie" << std::endl;
+    return returnvalue::FAILED;
+  }
+  rwCookies[rwCookie->rwIdx] = rwCookie;
+
+  return returnvalue::OK;
+}
+
+ReturnValue_t RwPollingTask::sendMessage(CookieIF* cookie, const uint8_t* sendData,
+                                         size_t sendLen) {
+  if (sendData == nullptr or sendLen < 8) {
+    return DeviceHandlerIF::INVALID_DATA;
+  }
+  int32_t speed = 0;
+  uint16_t rampTime = 0;
+  const uint8_t* currentBuf = sendData;
+  bool setSpeed = currentBuf[0];
+  currentBuf += 1;
+  sendLen -= 1;
+  SerializeAdapter::deSerialize(&speed, &currentBuf, &sendLen, SerializeIF::Endianness::MACHINE);
+  SerializeAdapter::deSerialize(&rampTime, &currentBuf, &sendLen, SerializeIF::Endianness::MACHINE);
+  rws::SpecialRwRequest specialRequest = rws::SpecialRwRequest::REQUEST_NONE;
+  if (sendLen == 8 and sendData[7] < static_cast<uint8_t>(rws::SpecialRwRequest::NUM_REQUESTS)) {
+    specialRequest = static_cast<rws::SpecialRwRequest>(sendData[7]);
+  }
+  RwCookie* rwCookie = dynamic_cast<RwCookie*>(cookie);
+  if (rwCookie == nullptr) {
+    return returnvalue::FAILED;
+  }
+  {
+    MutexGuard mg(ipcLock);
+    rwCookie->setSpeed = setSpeed;
+    rwCookie->currentRwSpeed = speed;
+    rwCookie->currentRampTime = rampTime;
+    rwCookie->specialRequest = specialRequest;
+    if (state == InternalState::IDLE) {
+      state = InternalState::IS_BUSY;
+      semaphore->release();
+    }
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t RwPollingTask::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
+
+ReturnValue_t RwPollingTask::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t RwPollingTask::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
+  RwCookie* rwCookie = dynamic_cast<RwCookie*>(cookie);
+  if (rwCookie == nullptr or rwCookie->bufLock == nullptr) {
+    return returnvalue::FAILED;
+  }
+  {
+    MutexGuard mg(rwCookie->bufLock);
+    memcpy(rwCookie->exchangeBuf.data(), rwCookie->replyBuf.data(), rwCookie->replyBuf.size());
+  }
+  *buffer = rwCookie->exchangeBuf.data();
+  *size = rwCookie->exchangeBuf.size();
+  return returnvalue::OK;
+}
+
+ReturnValue_t RwPollingTask::writeAndReadAllRws(DeviceCommandId_t id) {
+  // Stopwatch watch;
+  ReturnValue_t result = returnvalue::OK;
+
+  int fd = 0;
+  result = openSpi(O_RDWR, fd);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  for (unsigned idx = 0; idx < rwCookies.size(); idx++) {
+    if (skipCommandingForRw[idx]) {
+      continue;
+    }
+    result = sendOneMessage(fd, *rwCookies[idx]);
+    if (result != returnvalue::OK) {
+      closeSpi(fd);
+      return returnvalue::FAILED;
+    }
+  }
+
+  closeSpi(fd);
+  return readAllRws(id);
+}
+
+ReturnValue_t RwPollingTask::openSpi(int flags, int& fd) {
+  fd = open(spiDev, flags);
+  if (fd < 0) {
+    sif::error << "RwPollingTask::openSpi: Failed to open device file" << std::endl;
+    return SpiComIF::OPENING_FILE_FAILED;
+  }
+
+  return returnvalue::OK;
+}
+
+ReturnValue_t RwPollingTask::readNextReply(RwCookie& rwCookie, uint8_t* replyBuf,
+                                           size_t maxReplyLen) {
+  ReturnValue_t result = returnvalue::OK;
+  int fd = 0;
+  gpioId_t gpioId = rwCookie.getChipSelectPin();
+  uint8_t byteRead = 0;
+  result = openSpi(O_RDWR, fd);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  pullCsLow(gpioId, gpioIF);
+  bool lastByteWasFrameMarker = false;
+  Countdown cd(2000);
+  size_t readIdx = 0;
+
+  while (true) {
+    lastByteWasFrameMarker = false;
+    if (read(fd, &byteRead, 1) != 1) {
+      sif::error << "RwPollingTask: Read failed. " << strerror(errno) << std::endl;
+      pullCsHigh(gpioId, gpioIF);
+      closeSpi(fd);
+      return rws::SPI_READ_FAILURE;
+    }
+    if (byteRead == rws::FRAME_DELIMITER) {
+      lastByteWasFrameMarker = true;
+    }
+    // Start of frame detected.
+    if (byteRead != rws::FRAME_DELIMITER and not lastByteWasFrameMarker) {
+      break;
+    }
+
+    if (readIdx % 100 == 0 && cd.hasTimedOut()) {
+      pullCsHigh(gpioId, gpioIF);
+      closeSpi(fd);
+      return rws::SPI_READ_FAILURE;
+    }
+    readIdx++;
+  }
+
+#if FSFW_HAL_SPI_WIRETAPPING == 1
+  sif::info << "RW start marker detected" << std::endl;
+#endif
+
+  size_t decodedFrameLen = 0;
+  MutexGuard mg(rwCookie.bufLock);
+
+  while (decodedFrameLen < maxReplyLen) {
+    // First byte already read in
+    if (decodedFrameLen != 0) {
+      byteRead = 0;
+      if (read(fd, &byteRead, 1) != 1) {
+        sif::error << "RwPollingTask: Read failed" << std::endl;
+        result = rws::SPI_READ_FAILURE;
+        break;
+      }
+    }
+
+    if (byteRead == rws::FRAME_DELIMITER) {
+      // Reached end of frame
+      break;
+    } else if (byteRead == 0x7D) {
+      if (read(fd, &byteRead, 1) != 1) {
+        sif::error << "RwPollingTask: Read failed" << std::endl;
+        result = rws::SPI_READ_FAILURE;
+        break;
+      }
+      if (byteRead == 0x5E) {
+        *(replyBuf + decodedFrameLen) = 0x7E;
+        decodedFrameLen++;
+        continue;
+      } else if (byteRead == 0x5D) {
+        *(replyBuf + decodedFrameLen) = 0x7D;
+        decodedFrameLen++;
+        continue;
+      } else {
+        sif::error << "RwPollingTask: Invalid substitute" << std::endl;
+        result = rws::INVALID_SUBSTITUTE;
+        break;
+      }
+    } else {
+      *(replyBuf + decodedFrameLen) = byteRead;
+      decodedFrameLen++;
+      continue;
+    }
+
+    // Check end marker.
+    /**
+     * There might be the unlikely case that each byte in a get-telemetry reply has been
+     * replaced by its substitute. Then the next byte must correspond to the end sign 0x7E.
+     * Otherwise there might be something wrong.
+     */
+    if (decodedFrameLen == maxReplyLen) {
+      if (read(fd, &byteRead, 1) != 1) {
+        sif::error << "rwSpiCallback::spiCallback: Failed to read last byte" << std::endl;
+        result = rws::SPI_READ_FAILURE;
+        break;
+      }
+      if (byteRead != rws::FRAME_DELIMITER) {
+        sif::error << "rwSpiCallback::spiCallback: Missing end sign "
+                   << static_cast<int>(rws::FRAME_DELIMITER) << std::endl;
+        decodedFrameLen--;
+        result = rws::MISSING_END_SIGN;
+        break;
+      }
+    }
+    result = returnvalue::OK;
+  }
+
+  pullCsHigh(gpioId, gpioIF);
+  closeSpi(fd);
+  return result;
+}
+
+ReturnValue_t RwPollingTask::writeOneRwCmd(uint8_t rwIdx, int fd) {
+  ReturnValue_t result = sendOneMessage(fd, *rwCookies[rwIdx]);
+  if (result != returnvalue::OK) {
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t RwPollingTask::readAllRws(DeviceCommandId_t id) {
+  // SPI dev will be opened in readNextReply on demand.
+  for (unsigned idx = 0; idx < rwCookies.size(); idx++) {
+    if (((id == rws::SET_SPEED) and !rwCookies[idx]->setSpeed) or skipCommandingForRw[idx]) {
+      continue;
+    }
+    uint8_t* replyBuf;
+    size_t maxReadLen = idAndIdxToReadBuffer(id, idx, &replyBuf);
+    ReturnValue_t result = readNextReply(*rwCookies[idx], replyBuf + 1, maxReadLen);
+    if (result == returnvalue::OK) {
+      // The first byte is always a flag which shows whether the value was read
+      // properly at least once.
+      replyBuf[0] = true;
+    }
+  }
+  // SPI is closed in readNextReply as well.
+  return returnvalue::OK;
+}
+
+size_t RwPollingTask::idAndIdxToReadBuffer(DeviceCommandId_t id, uint8_t rwIdx, uint8_t** ptr) {
+  uint8_t* rawStart = rwCookies[rwIdx]->replyBuf.data();
+  RwReplies replies(rawStart);
+  switch (id) {
+    case (rws::GET_RW_STATUS): {
+      *ptr = replies.rwStatusReply;
+      break;
+    }
+    case (rws::SET_SPEED): {
+      *ptr = replies.setSpeedReply;
+      break;
+    }
+    case (rws::CLEAR_LAST_RESET_STATUS): {
+      *ptr = replies.clearLastResetStatusReply;
+      break;
+    }
+    case (rws::GET_LAST_RESET_STATUS): {
+      *ptr = replies.getLastResetStatusReply;
+      break;
+    }
+    case (rws::GET_TEMPERATURE): {
+      *ptr = replies.readTemperatureReply;
+      break;
+    }
+    case (rws::GET_TM): {
+      *ptr = replies.hkDataReply;
+      break;
+    }
+    case (rws::INIT_RW_CONTROLLER): {
+      *ptr = replies.initRwControllerReply;
+      break;
+    }
+    default: {
+      sif::error << "no reply buffer for rw command " << id << std::endl;
+      *ptr = replies.dummyPointer;
+      return 0;
+    }
+  }
+  return rws::idToPacketLen(id);
+}
+
+void RwPollingTask::fillSpecialRequestArray() {
+  for (unsigned idx = 0; idx < rwCookies.size(); idx++) {
+    if (skipCommandingForRw[idx]) {
+      specialRequestIds[idx] = DeviceHandlerIF::NO_COMMAND_ID;
+      continue;
+    }
+    switch (rwCookies[idx]->specialRequest) {
+      case (rws::SpecialRwRequest::GET_TM): {
+        specialRequestIds[idx] = rws::GET_TM;
+        break;
+      }
+      case (rws::SpecialRwRequest::INIT_RW_CONTROLLER): {
+        specialRequestIds[idx] = rws::INIT_RW_CONTROLLER;
+        break;
+      }
+      default: {
+        specialRequestIds[idx] = DeviceHandlerIF::NO_COMMAND_ID;
+      }
+    }
+  }
+}
+
+void RwPollingTask::handleSpecialRequests() {
+  int fd = 0;
+  fillSpecialRequestArray();
+  ReturnValue_t result = openSpi(O_RDWR, fd);
+  if (result != returnvalue::OK) {
+    return;
+  }
+  for (unsigned idx = 0; idx < rwCookies.size(); idx++) {
+    if (specialRequestIds[idx] == DeviceHandlerIF::NO_COMMAND_ID) {
+      continue;
+    }
+    prepareSimpleCommand(specialRequestIds[idx]);
+    writeOneRwCmd(idx, fd);
+  }
+  closeSpi(fd);
+  usleep(rws::SPI_REPLY_DELAY);
+  for (unsigned idx = 0; idx < rwCookies.size(); idx++) {
+    if (specialRequestIds[idx] == DeviceHandlerIF::NO_COMMAND_ID) {
+      continue;
+    }
+    uint8_t* replyBuf;
+    size_t maxReadLen = idAndIdxToReadBuffer(specialRequestIds[idx], idx, &replyBuf);
+    result = readNextReply(*rwCookies[idx], replyBuf, maxReadLen);
+    if (result == returnvalue::OK) {
+      // The first byte is always a flag which shows whether the value was read
+      // properly at least once.
+      replyBuf[0] = true;
+    }
+  }
+}
+
+void RwPollingTask::setAllReadFlagsFalse() {
+  for (auto& rwCookie : rwCookies) {
+    RwReplies replies(rwCookie->replyBuf.data());
+    replies.getLastResetStatusReply[0] = false;
+    replies.clearLastResetStatusReply[0] = false;
+    replies.hkDataReply[0] = false;
+    replies.readTemperatureReply[0] = false;
+    replies.rwStatusReply[0] = false;
+    replies.setSpeedReply[0] = false;
+    replies.initRwControllerReply[0] = false;
+  }
+}
+
+// This closes the SPI
+void RwPollingTask::closeSpi(int fd) {
+  // This will perform the function to close the SPI
+  close(fd);
+  // The SPI is now closed.
+}
+
+ReturnValue_t RwPollingTask::sendOneMessage(int fd, RwCookie& rwCookie) {
+  gpioId_t gpioId = rwCookie.getChipSelectPin();
+  if (spiLock == nullptr) {
+    sif::debug << "rwSpiCallback::spiCallback: Mutex or GPIO interface invalid" << std::endl;
+    return returnvalue::FAILED;
+  }
+  // Add datalinklayer like specified in the datasheet.
+  size_t lenToSend = 0;
+  rws::encodeHdlc(writeBuffer.data(), writeLen, encodedBuffer.data(), lenToSend);
+  pullCsLow(gpioId, gpioIF);
+  if (write(fd, encodedBuffer.data(), lenToSend) != static_cast<ssize_t>(lenToSend)) {
+    sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
+    pullCsHigh(gpioId, gpioIF);
+    return rws::SPI_WRITE_FAILURE;
+  }
+  pullCsHigh(gpioId, gpioIF);
+  return returnvalue::OK;
+}
+
+ReturnValue_t RwPollingTask::pullCsLow(gpioId_t gpioId, GpioIF& gpioIF) {
+  ReturnValue_t result = spiLock->lockMutex(TIMEOUT_TYPE, TIMEOUT_MS);
+  if (result != returnvalue::OK) {
+    sif::debug << "RwPollingTask::pullCsLow: Failed to lock mutex" << std::endl;
+    return result;
+  }
+  // Pull SPI CS low. For now, no support for active high given
+  if (gpioId != gpio::NO_GPIO) {
+    result = gpioIF.pullLow(gpioId);
+    if (result != returnvalue::OK) {
+      sif::error << "RwPollingTask::pullCsLow: Failed to pull chip select low" << std::endl;
+      return result;
+    }
+  }
+  return returnvalue::OK;
+}
+
+void RwPollingTask::pullCsHigh(gpioId_t gpioId, GpioIF& gpioIF) {
+  if (gpioId != gpio::NO_GPIO) {
+    if (gpioIF.pullHigh(gpioId) != returnvalue::OK) {
+      sif::error << "closeSpi: Failed to pull chip select high" << std::endl;
+    }
+  }
+  if (spiLock->unlockMutex() != returnvalue::OK) {
+    sif::error << "RwPollingTask::pullCsHigh: Failed to unlock mutex" << std::endl;
+    ;
+  }
+}
+
+void RwPollingTask::prepareSimpleCommand(DeviceCommandId_t id) {
+  writeBuffer[0] = static_cast<uint8_t>(id);
+  uint16_t crc = CRC::crc16ccitt(writeBuffer.data(), 1, 0xFFFF);
+  writeBuffer[1] = static_cast<uint8_t>(crc & 0xFF);
+  writeBuffer[2] = static_cast<uint8_t>(crc >> 8 & 0xFF);
+  writeLen = 3;
+}
+
+ReturnValue_t RwPollingTask::prepareSetSpeedCmd(uint8_t rwIdx) {
+  writeBuffer[0] = static_cast<uint8_t>(rws::SET_SPEED);
+  uint8_t* serPtr = writeBuffer.data() + 1;
+  int32_t speedToSet = 0;
+  uint16_t rampTimeToSet = 10;
+  {
+    MutexGuard mg(ipcLock);
+    speedToSet = rwCookies[rwIdx]->currentRwSpeed;
+    rampTimeToSet = rwCookies[rwIdx]->currentRampTime;
+  }
+  size_t serLen = 1;
+  SerializeAdapter::serialize(&speedToSet, &serPtr, &serLen, writeBuffer.size(),
+                              SerializeIF::Endianness::LITTLE);
+  SerializeAdapter::serialize(&rampTimeToSet, &serPtr, &serLen, writeBuffer.size(),
+                              SerializeIF::Endianness::LITTLE);
+
+  uint16_t crc = CRC::crc16ccitt(writeBuffer.data(), 7, 0xFFFF);
+  writeBuffer[7] = static_cast<uint8_t>(crc & 0xFF);
+  writeBuffer[8] = static_cast<uint8_t>((crc >> 8) & 0xFF);
+  writeLen = 9;
+  return returnvalue::OK;
+}

linux/acs/RwPollingTask.h

@@ -0,0 +1,91 @@
+#ifndef LINUX_DEVICES_RWPOLLINGTASK_H_
+#define LINUX_DEVICES_RWPOLLINGTASK_H_
+
+#include <fsfw/devicehandlers/DeviceCommunicationIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+#include <fsfw/tasks/SemaphoreIF.h>
+#include <fsfw_hal/common/gpio/GpioIF.h>
+#include <fsfw_hal/linux/spi/SpiComIF.h>
+#include <fsfw_hal/linux/spi/SpiCookie.h>
+
+#include "mission/acs/rwHelpers.h"
+
+class RwCookie : public SpiCookie {
+  friend class RwPollingTask;
+
+ public:
+  static constexpr size_t REPLY_BUF_LEN = 524;
+  RwCookie(uint8_t rwIdx, address_t spiAddress, gpioId_t chipSelect, const size_t maxSize,
+           spi::SpiModes spiMode, uint32_t spiSpeed)
+      : SpiCookie(spiAddress, chipSelect, maxSize, spiMode, spiSpeed), rwIdx(rwIdx) {
+    bufLock = MutexFactory::instance()->createMutex();
+  }
+
+ private:
+  std::array<uint8_t, REPLY_BUF_LEN> replyBuf{};
+  std::array<uint8_t, REPLY_BUF_LEN> exchangeBuf{};
+  MutexIF* bufLock;
+  bool setSpeed = true;
+  int32_t currentRwSpeed = 0;
+  uint16_t currentRampTime = 0;
+  rws::SpecialRwRequest specialRequest = rws::SpecialRwRequest::REQUEST_NONE;
+  uint8_t rwIdx;
+};
+
+class RwPollingTask : public SystemObject, public ExecutableObjectIF, public DeviceCommunicationIF {
+ public:
+  RwPollingTask(object_id_t objectId, const char* spiDev, GpioIF& gpioIF);
+
+  ReturnValue_t performOperation(uint8_t operationCode) override;
+  ReturnValue_t initialize() override;
+
+ private:
+  enum class InternalState { IDLE, IS_BUSY } state = InternalState::IDLE;
+  SemaphoreIF* semaphore;
+  bool debugMode = false;
+  bool modeAndSpeedWasSet = false;
+  MutexIF* ipcLock;
+  MutexIF* spiLock;
+  const char* spiDev;
+  GpioIF& gpioIF;
+  std::array<bool, 4> skipCommandingForRw;
+  std::array<DeviceCommandId_t, 4> specialRequestIds;
+  std::array<RwCookie*, 4> rwCookies;
+  std::array<uint8_t, rws::MAX_CMD_SIZE> writeBuffer;
+  std::array<uint8_t, rws::MAX_CMD_SIZE * 2> encodedBuffer;
+
+  size_t writeLen = 0;
+  static constexpr MutexIF::TimeoutType TIMEOUT_TYPE = MutexIF::TimeoutType::WAITING;
+  static constexpr uint32_t TIMEOUT_MS = 20;
+  static constexpr uint8_t MAX_RETRIES_REPLY = 5;
+
+  // DeviceCommunicationIF overrides
+  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 writeAndReadAllRws(DeviceCommandId_t id);
+  ReturnValue_t writeOneRwCmd(uint8_t rwIdx, int fd);
+  ReturnValue_t readAllRws(DeviceCommandId_t id);
+
+  ReturnValue_t sendOneMessage(int fd, RwCookie& rwCookie);
+  ReturnValue_t readNextReply(RwCookie& rwCookie, uint8_t* replyBuf, size_t maxReplyLen);
+  void handleSpecialRequests();
+
+  ReturnValue_t openSpi(int flags, int& fd);
+  ReturnValue_t pullCsLow(gpioId_t gpioId, GpioIF& gpioIF);
+  void prepareSimpleCommand(DeviceCommandId_t id);
+  ReturnValue_t prepareSetSpeedCmd(uint8_t rwIdx);
+
+  size_t idAndIdxToReadBuffer(DeviceCommandId_t id, uint8_t rwIdx, uint8_t** readPtr);
+  void fillSpecialRequestArray();
+  void setAllReadFlagsFalse();
+
+  void pullCsHigh(gpioId_t gpioId, GpioIF& gpioIF);
+  void closeSpi(int);
+};
+
+#endif /* LINUX_DEVICES_RWPOLLINGTASK_H_ */

linux/acs/SusPolling.cpp

@@ -0,0 +1,220 @@
+#include "SusPolling.h"
+
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw/timemanager/Stopwatch.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);
+    {
+      // Takes 4-5 ms in debug mode.
+      // Stopwatch watch;
+      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::IS_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/acs/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/acs/acsBoardPolling.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, IS_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/acs/startracker/ArcsecDatalinkLayer.cpp

@@ -0,0 +1,73 @@
+#include "ArcsecDatalinkLayer.h"
+
+ArcsecDatalinkLayer::ArcsecDatalinkLayer() : decodeRingBuf(BUFFER_LENGTHS, true) { slipInit(); }
+
+ArcsecDatalinkLayer::~ArcsecDatalinkLayer() {}
+
+ReturnValue_t ArcsecDatalinkLayer::checkRingBufForFrame(const uint8_t** decodedFrame,
+                                                        size_t& frameLen) {
+  size_t currentLen = decodeRingBuf.getAvailableReadData();
+  if (currentLen == 0) {
+    return DEC_IN_PROGRESS;
+  }
+  decodeRingBuf.readData(rxAnalysisBuffer, currentLen);
+  for (size_t idx = 0; idx < currentLen; idx++) {
+    enum arc_dec_result decResult =
+        arc_transport_decode_body(rxAnalysisBuffer[idx], &slipInfo, decodedRxFrame, &rxFrameSize);
+    switch (decResult) {
+      case ARC_DEC_INPROGRESS: {
+        break;
+      }
+      case ARC_DEC_ERROR_FRAME_SHORT: {
+        decodeRingBuf.deleteData(idx);
+        return REPLY_TOO_SHORT;
+      }
+      case ARC_DEC_ERROR_CHECKSUM:
+        decodeRingBuf.deleteData(idx);
+        return CRC_FAILURE;
+      case ARC_DEC_ASYNC:
+      case ARC_DEC_SYNC: {
+        // Reset length of SLIP struct for next frame
+        slipInfo.length = 0;
+        if (decodedFrame != nullptr) {
+          *decodedFrame = decodedRxFrame;
+        }
+        frameLen = rxFrameSize;
+        decodeRingBuf.deleteData(idx);
+        return returnvalue::OK;
+      }
+      default:
+        sif::debug << "ArcsecDatalinkLayer::decodeFrame: Unknown result code" << std::endl;
+        break;
+        return returnvalue::FAILED;
+    }
+  }
+  decodeRingBuf.deleteData(currentLen);
+  return DEC_IN_PROGRESS;
+}
+
+ReturnValue_t ArcsecDatalinkLayer::feedData(const uint8_t* rawData, size_t rawDataLen) {
+  if (rawDataLen > 4096) {
+    sif::error << "ArcsecDatalinklayer: Can not write more than 4096 bytes to ring buffer"
+               << std::endl;
+    return returnvalue::FAILED;
+  }
+  return decodeRingBuf.writeData(rawData, rawDataLen);
+}
+
+void ArcsecDatalinkLayer::reset() {
+  slipInit();
+  decodeRingBuf.clear();
+}
+
+void ArcsecDatalinkLayer::slipInit() {
+  slip_decode_init(rxBufferArc, sizeof(rxBufferArc), &slipInfo);
+}
+
+void ArcsecDatalinkLayer::encodeFrame(const uint8_t* data, size_t length, const uint8_t** txFrame,
+                                      size_t& size) {
+  arc_transport_encode_body(data, length, txEncoded, &size);
+  if (txFrame != nullptr) {
+    *txFrame = txEncoded;
+  }
+}

linux/acs/startracker/ArcsecDatalinkLayer.h

@@ -0,0 +1,90 @@
+#ifndef BSP_Q7S_DEVICES_ARCSECDATALINKLAYER_H_
+#define BSP_Q7S_DEVICES_ARCSECDATALINKLAYER_H_
+
+#include <fsfw/container/SimpleRingBuffer.h>
+#include <fsfw/devicehandlers/CookieIF.h>
+
+#include "arcsec/common/misc.h"
+#include "eive/resultClassIds.h"
+#include "fsfw/returnvalues/returnvalue.h"
+#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
+
+/**
+ * @brief   Helper class to handle the datalinklayer of replies from the star tracker of arcsec.
+ */
+class ArcsecDatalinkLayer {
+ public:
+  static const uint8_t INTERFACE_ID = CLASS_ID::STR_HANDLER;
+
+  //! [EXPORT] : [COMMENT] More data required to complete frame
+  static const ReturnValue_t DEC_IN_PROGRESS = MAKE_RETURN_CODE(0xA0);
+  //! [EXPORT] : [COMMENT] Data too short to represent a valid frame
+  static const ReturnValue_t REPLY_TOO_SHORT = MAKE_RETURN_CODE(0xA1);
+  //! [EXPORT] : [COMMENT] Detected CRC failure in received frame
+  static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xA2);
+
+  static const uint8_t STATUS_OK = 0;
+
+  static constexpr size_t BUFFER_LENGTHS = 4096;
+
+  ArcsecDatalinkLayer();
+  virtual ~ArcsecDatalinkLayer();
+
+  /**
+   * Feed received data to the internal ring buffer.
+   * @param rawData
+   * @param rawDataLen
+   * @return
+   */
+  ReturnValue_t feedData(const uint8_t* rawData, size_t rawDataLen);
+
+  /**
+   * Runs the arcsec datalink layer decoding algorithm on the data in the ring buffer, decoding
+   * frames in the process.
+   * @param decodedFrame
+   * @param frameLen
+   * @return
+   *   - returnvalue::OK if a frame was found
+   *   - DEC_IN_PROGRESS if frame decoding is in progress
+   *   - Anything else is a decoding error
+   */
+  ReturnValue_t checkRingBufForFrame(const uint8_t** decodedFrame, size_t& frameLen);
+
+  /**
+   * @brief   SLIP encodes data pointed to by data pointer.
+   *
+   * @param data   Pointer to data to encode
+   * @param length Length of buffer to encode
+   */
+  void encodeFrame(const uint8_t* data, size_t length, const uint8_t** txFrame, size_t& frameLen);
+
+  void reset();
+
+ private:
+  static const uint8_t ID_OFFSET = 1;
+  static const uint8_t STATUS_OFFSET = 2;
+
+  // User to buffer and analyse data and allow feeding and checking for frames asychronously.
+  SimpleRingBuffer decodeRingBuf;
+  uint8_t rxAnalysisBuffer[BUFFER_LENGTHS];
+
+  // Used by arcsec slip decoding function to process received data. This should only be written
+  // to or read from by arcsec functions!
+  uint8_t rxBufferArc[startracker::MAX_FRAME_SIZE];
+  // Decoded frame will be copied to this buffer
+  uint8_t decodedRxFrame[startracker::MAX_FRAME_SIZE];
+  // Size of decoded frame
+  uint32_t rxFrameSize = 0;
+
+  // Buffer where encoded frames will be stored. First byte of encoded frame represents type of
+  // reply
+  uint8_t txEncoded[startracker::MAX_FRAME_SIZE * 2 + 2];
+  // Size of encoded frame
+  uint32_t txFrameSize = 0;
+
+  slip_decode_state slipInfo;
+
+  void slipInit();
+};
+
+#endif /* BSP_Q7S_DEVICES_ARCSECDATALINKLAYER_H_ */

linux/acs/startracker/ArcsecJsonParamBase.cpp

@@ -0,0 +1,101 @@
+#include "ArcsecJsonParamBase.h"
+
+#include "arcsecJsonKeys.h"
+
+ArcsecJsonParamBase::ArcsecJsonParamBase(std::string setName) : setName(setName) {}
+
+ReturnValue_t ArcsecJsonParamBase::create(uint8_t* buffer) {
+  ReturnValue_t result = createCommand(buffer);
+  if (result != returnvalue::OK) {
+    sif::warning << "ArcsecJsonParamBase::create: Failed to create parameter command for set "
+                 << setName << std::endl;
+  }
+  return result;
+}
+
+ReturnValue_t ArcsecJsonParamBase::getParam(const std::string name, std::string& value) {
+  for (json::iterator it = set.begin(); it != set.end(); ++it) {
+    if ((*it)[arcseckeys::NAME] == name) {
+      value = (*it)[arcseckeys::VALUE];
+      convertEmpty(value);
+      return returnvalue::OK;
+    }
+  }
+  return PARAM_NOT_EXISTS;
+}
+
+void ArcsecJsonParamBase::convertEmpty(std::string& value) {
+  if (value == "") {
+    value = "0";
+  }
+}
+
+void ArcsecJsonParamBase::addfloat(const std::string value, uint8_t* buffer) {
+  float param = std::stof(value);
+  std::memcpy(buffer, &param, sizeof(param));
+}
+
+void ArcsecJsonParamBase::adduint8(const std::string value, uint8_t* buffer) {
+  uint8_t param = std::stoi(value);
+  std::memcpy(buffer, &param, sizeof(param));
+}
+
+void ArcsecJsonParamBase::addint16(const std::string value, uint8_t* buffer) {
+  int16_t param = std::stoi(value);
+  std::memcpy(buffer, &param, sizeof(param));
+}
+
+void ArcsecJsonParamBase::adduint16(const std::string value, uint8_t* buffer) {
+  uint16_t param = std::stoi(value);
+  std::memcpy(buffer, &param, sizeof(param));
+}
+
+void ArcsecJsonParamBase::adduint32(const std::string value, uint8_t* buffer) {
+  uint32_t param = std::stoi(value);
+  std::memcpy(buffer, &param, sizeof(param));
+}
+
+void ArcsecJsonParamBase::addSetParamHeader(uint8_t* buffer, uint8_t setId) {
+  *buffer = static_cast<uint8_t>(TMTC_SETPARAMREQ);
+  *(buffer + 1) = setId;
+}
+
+ReturnValue_t ArcsecJsonParamBase::init(const std::string filename) {
+  ReturnValue_t result = returnvalue::OK;
+  if (not std::filesystem::exists(filename)) {
+    sif::warning << "ArcsecJsonParamBase::init: JSON file " << filename << " does not exist"
+                 << std::endl;
+    return JSON_FILE_NOT_EXISTS;
+  }
+  try {
+    createJsonObject(filename);
+    result = initSet();
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    return returnvalue::OK;
+  } catch (json::exception& e) {
+    // TODO: Re-create json file from backup here.
+    return returnvalue::FAILED;
+  }
+}
+
+void ArcsecJsonParamBase::createJsonObject(const std::string fullname) {
+  json j;
+  std::ifstream file(fullname);
+  file >> j;
+  file.close();
+  properties = j[arcseckeys::PROPERTIES];
+}
+
+ReturnValue_t ArcsecJsonParamBase::initSet() {
+  for (json::iterator it = properties.begin(); it != properties.end(); ++it) {
+    if ((*it)["name"] == setName) {
+      set = (*it)["fields"];
+      return returnvalue::OK;
+    }
+  }
+  sif::warning << "ArcsecJsonParamBase::initSet: Set " << setName << "not present in json file"
+               << std::endl;
+  return SET_NOT_EXISTS;
+}

linux/acs/startracker/ArcsecJsonParamBase.h

@@ -0,0 +1,145 @@
+#ifndef BSP_Q7S_DEVICES_STARTRACKER_ARCSECJSONPARAMBASE_H_
+#define BSP_Q7S_DEVICES_STARTRACKER_ARCSECJSONPARAMBASE_H_
+
+#include <filesystem>
+#include <fstream>
+#include <nlohmann/json.hpp>
+
+#include "arcsec/common/generated/tmtcstructs.h"
+#include "arcsec/common/genericstructs.h"
+#include "eive/resultClassIds.h"
+#include "fsfw/returnvalues/returnvalue.h"
+#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
+
+using json = nlohmann::json;
+
+/**
+ * @brief   Base class for creation of parameter configuration commands. Reads parameter set
+ *          from a json file located on the filesystem and generates the appropriate command
+ *          to apply the parameters to the star tracker software.
+ *
+ * @author  J. Meier
+ */
+class ArcsecJsonParamBase {
+ public:
+  static const uint8_t INTERFACE_ID = CLASS_ID::ARCSEC_JSON_BASE;
+  //! [EXPORT] : [COMMENT] Specified json file does not exist
+  static const ReturnValue_t JSON_FILE_NOT_EXISTS = MAKE_RETURN_CODE(1);
+  //! [EXPORT] : [COMMENT] Requested set does not exist in json file
+  static const ReturnValue_t SET_NOT_EXISTS = MAKE_RETURN_CODE(2);
+  //! [EXPORT] : [COMMENT] Requested parameter does not exist in json file
+  static const ReturnValue_t PARAM_NOT_EXISTS = MAKE_RETURN_CODE(3);
+
+  virtual ~ArcsecJsonParamBase() = default;
+  /**
+   * @brief Constructor
+   *
+   * @param fullname  Name with absolute path of json file containing the parameters to set.
+   */
+  ArcsecJsonParamBase(std::string setName);
+
+  /**
+   * @brief   Initializes the properties json object and the set json object
+   *
+   * @param fullname  Name including absolute path to json file
+   * @param setName   The name of the set to work on
+   *
+   * @param return    JSON_FILE_NOT_EXISTS if specified file does not exist, otherwise
+   *                  returnvalue::OK
+   */
+  ReturnValue_t init(const std::string filename);
+
+  /**
+   * @brief   Fills a buffer with a parameter set
+   *
+   * @param fullname  The name including the absolute path of the json file containing the
+   *                  parameter set.
+   * @param buffer    Pointer to the buffer the command will be written to
+   */
+  ReturnValue_t create(uint8_t* buffer);
+
+  /**
+   * @brief   Returns the size of the parameter command.
+   */
+  virtual size_t getSize() = 0;
+
+ protected:
+  /**
+   * @brief   Reads the value of a parameter from a json set
+   *
+   * @param name  The name of the parameter
+   * @param value The string representation of the read value
+   *
+   * @return  returnvalue::OK if successful, otherwise PARAM_NOT_EXISTS
+   */
+  ReturnValue_t getParam(const std::string name, std::string& value);
+
+  /**
+   * @brief   Converts empty string which is equal to define a value as zero.
+   */
+  void convertEmpty(std::string& value);
+
+  /**
+   * @brief   This function adds a float represented as string to a buffer
+   *
+   * @param value     The float in string representation to add
+   * @param buffer    Pointer to the buffer the float will be written to
+   */
+  void addfloat(const std::string value, uint8_t* buffer);
+
+  /**
+   * @brief   This function adds a uint8_t represented as string to a buffer
+   *
+   * @param value     The uint8_t in string representation to add
+   * @param buffer    Pointer to the buffer the uint8_t will be written to
+   */
+  void adduint8(const std::string value, uint8_t* buffer);
+
+  /**
+   * @brief   This function adds a int16_t represented as string to a buffer
+   *
+   * @param value     The int16_t in string representation to add
+   * @param buffer    Pointer to the buffer the int16_t will be written to
+   */
+  void addint16(const std::string value, uint8_t* buffer);
+
+  /**
+   * @brief   This function adds a uint16_t represented as string to a buffer
+   *
+   * @param value     The uint16_t in string representation to add
+   * @param buffer    Pointer to the buffer the uint16_t will be written to
+   */
+  void adduint16(const std::string value, uint8_t* buffer);
+
+  /**
+   * @brief   This function adds a uint32_t represented as string to a buffer
+   *
+   * @param value     The uint32_t in string representation to add
+   * @param buffer    Pointer to the buffer the uint32_t will be written to
+   */
+  void adduint32(const std::string value, uint8_t* buffer);
+
+  void addSetParamHeader(uint8_t* buffer, uint8_t setId);
+
+ private:
+  json properties;
+  json set;
+  std::string setName;
+
+  /**
+   * @brief   This function must be implemented by the derived class to define creation of a
+   *          parameter command.
+   */
+  virtual ReturnValue_t createCommand(uint8_t* buffer) = 0;
+
+  void createJsonObject(const std::string fullname);
+
+  /**
+   * @brief   Extracts the json set object form the json file
+   *
+   * @param setName   The name of the set to create the json object from
+   */
+  ReturnValue_t initSet();
+};
+
+#endif /* BSP_Q7S_DEVICES_STARTRACKER_ARCSECJSONPARAMBASE_H_ */

linux/acs/startracker/CMakeLists.txt

@@ -0,0 +1,4 @@
+target_sources(
+  ${OBSW_NAME}
+  PRIVATE StarTrackerHandler.cpp strJsonCommands.cpp ArcsecDatalinkLayer.cpp
+          ArcsecJsonParamBase.cpp StrComHandler.cpp helpers.cpp)

linux/acs/startracker/StarTrackerHandler.h

@@ -0,0 +1,499 @@
+#ifndef MISSION_DEVICES_STARTRACKERHANDLER_H_
+#define MISSION_DEVICES_STARTRACKERHANDLER_H_
+
+#include <fsfw/datapool/PoolReadGuard.h>
+
+#include <thread>
+
+#include "ArcsecJsonParamBase.h"
+#include "OBSWConfig.h"
+#include "StrComHandler.h"
+#include "arcsec/common/SLIP.h"
+#include "devices/powerSwitcherList.h"
+#include "fsfw/devicehandlers/DeviceHandlerBase.h"
+#include "fsfw/src/fsfw/serialize/SerializeAdapter.h"
+#include "fsfw/timemanager/Countdown.h"
+#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
+#include "strJsonCommands.h"
+
+/**
+ * @brief	This is the device handler for the star tracker from arcsec.
+ *
+ * @details Datasheet: https://eive-cloud.irs.uni-stuttgart.de/index.php/apps/files/?dir=/EIVE_IRS/
+ *                     Arbeitsdaten/08_Used%20Components/ArcSec_KULeuven_Startracker/
+ *                     Sagitta%201.0%20Datapack&fileid=659181
+ * @author	J. Meier
+ */
+class StarTrackerHandler : public DeviceHandlerBase {
+ public:
+  /**
+   * @brief Constructor
+   *
+   * @param objectId
+   * @param comIF
+   * @param comCookie
+   * @param gpioComIF	Pointer to gpio communication interface
+   * @param enablePin 	GPIO connected to the enable pin of the reaction wheels. Must be pulled
+   * 						to high to enable the device.
+   */
+  StarTrackerHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
+                     const char* jsonFileStr, StrComHandler* strHelper,
+                     power::Switch_t powerSwitch);
+  virtual ~StarTrackerHandler();
+
+  ReturnValue_t initialize() override;
+
+  /**
+   * @brief   Overwrite this function from DHB to handle commands executed by the str image
+   *          loader task.
+   */
+  ReturnValue_t executeAction(ActionId_t actionId, MessageQueueId_t commandedBy,
+                              const uint8_t* data, size_t size) override;
+
+  void performOperationHook() override;
+
+  Submode_t getInitialSubmode() override;
+
+  static const Submode_t SUBMODE_BOOTLOADER = 1;
+  static const Submode_t SUBMODE_FIRMWARE = 2;
+
+ 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 isModeCombinationValid(Mode_t mode, Submode_t submode) 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;
+  void setNormalDatapoolEntriesInvalid() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
+                                        LocalDataPoolManager& poolManager) override;
+  /**
+   * @brief   Overwritten here to always read all available data from theSerialComIF.
+   */
+  virtual size_t getNextReplyLength(DeviceCommandId_t deviceCommand) override;
+  virtual ReturnValue_t doSendReadHook() override;
+  ReturnValue_t getSwitches(const uint8_t** switches, uint8_t* numberOfSwitches) override;
+  virtual void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
+
+ private:
+  static const uint8_t INTERFACE_ID = CLASS_ID::STR_HANDLER;
+
+  //! [EXPORT] : [COMMENT] Status in temperature reply signals error
+  static const ReturnValue_t TEMPERATURE_REQ_FAILED = MAKE_RETURN_CODE(0xA0);
+  //! [EXPORT] : [COMMENT] Ping command failed
+  static const ReturnValue_t PING_FAILED = MAKE_RETURN_CODE(0xA1);
+  //! [EXPORT] : [COMMENT] Status in version reply signals error
+  static const ReturnValue_t VERSION_REQ_FAILED = MAKE_RETURN_CODE(0xA2);
+  //! [EXPORT] : [COMMENT] Status in interface reply signals error
+  static const ReturnValue_t INTERFACE_REQ_FAILED = MAKE_RETURN_CODE(0xA3);
+  //! [EXPORT] : [COMMENT] Status in power reply signals error
+  static const ReturnValue_t POWER_REQ_FAILED = MAKE_RETURN_CODE(0xA4);
+  //! [EXPORT] : [COMMENT] Status of reply to parameter set command signals error
+  static const ReturnValue_t SET_PARAM_FAILED = MAKE_RETURN_CODE(0xA5);
+  //! [EXPORT] : [COMMENT] Status of reply to action command signals error
+  static const ReturnValue_t ACTION_FAILED = MAKE_RETURN_CODE(0xA6);
+  //! [EXPORT] : [COMMENT] Received invalid path string. Exceeds allowed length
+  static const ReturnValue_t FILE_PATH_TOO_LONG = MAKE_RETURN_CODE(0xA7);
+  //! [EXPORT] : [COMMENT] Name of file received with command is too long
+  static const ReturnValue_t FILENAME_TOO_LONG = MAKE_RETURN_CODE(0xA8);
+  //! [EXPORT] : [COMMENT] Received version reply with invalid program ID
+  static const ReturnValue_t INVALID_PROGRAM = MAKE_RETURN_CODE(0xA9);
+  //! [EXPORT] : [COMMENT] Status field reply signals error
+  static const ReturnValue_t REPLY_ERROR = MAKE_RETURN_CODE(0xAA);
+  //! [EXPORT] : [COMMENT] Received command which is too short (some data is missing for proper
+  //! execution)
+  static const ReturnValue_t COMMAND_TOO_SHORT = MAKE_RETURN_CODE(0xAB);
+  //! [EXPORT] : [COMMENT] Received command with invalid length (too few or too many parameters)
+  static const ReturnValue_t INVALID_LENGTH = MAKE_RETURN_CODE(0xAC);
+  //! [EXPORT] : [COMMENT] Region mismatch between send and received data
+  static const ReturnValue_t REGION_MISMATCH = MAKE_RETURN_CODE(0xAD);
+  //! [EXPORT] : [COMMENT] Address mismatch between send and received data
+  static const ReturnValue_t ADDRESS_MISMATCH = MAKE_RETURN_CODE(0xAE);
+  //! [EXPORT] : [COMMENT] Length field mismatch between send and received data
+  static const ReturnValue_t lENGTH_MISMATCH = MAKE_RETURN_CODE(0xAF);
+  //! [EXPORT] : [COMMENT] Specified file does not exist
+  static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(0xB0);
+  //! [EXPORT] : [COMMENT] Download blob pixel command has invalid type field
+  static const ReturnValue_t INVALID_TYPE = MAKE_RETURN_CODE(0xB1);
+  //! [EXPORT] : [COMMENT] Received FPGA action command with invalid ID
+  static const ReturnValue_t INVALID_ID = MAKE_RETURN_CODE(0xB2);
+  //! [EXPORT] : [COMMENT] Received reply is too short
+  static const ReturnValue_t REPLY_TOO_SHORT = MAKE_RETURN_CODE(0xB3);
+  //! [EXPORT] : [COMMENT] Received reply with invalid CRC
+  static const ReturnValue_t CRC_FAILURE = MAKE_RETURN_CODE(0xB4);
+  //! [EXPORT] : [COMMENT] Star tracker handler currently executing a command and using the
+  //! communication interface
+  static const ReturnValue_t STR_HELPER_EXECUTING = MAKE_RETURN_CODE(0xB5);
+  //! [EXPORT] : [COMMENT] Star tracker is already in firmware mode
+  static const ReturnValue_t STARTRACKER_ALREADY_BOOTED = MAKE_RETURN_CODE(0xB6);
+  //! [EXPORT] : [COMMENT] Star tracker must be in firmware mode to run this command
+  static const ReturnValue_t STARTRACKER_NOT_RUNNING_FIRMWARE = MAKE_RETURN_CODE(0xB7);
+  //! [EXPORT] : [COMMENT] Star tracker must be in bootloader mode to run this command
+  static const ReturnValue_t STARTRACKER_NOT_RUNNING_BOOTLOADER = MAKE_RETURN_CODE(0xB8);
+
+  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::STR_HANDLER;
+
+  //! [EXPORT] : [COMMENT] Failed to boot firmware
+  static const Event BOOTING_FIRMWARE_FAILED_EVENT = MAKE_EVENT(1, severity::LOW);
+  //! [EXPORT] : [COMMENT] Failed to boot star tracker into bootloader mode
+  static const Event BOOTING_BOOTLOADER_FAILED_EVENT = MAKE_EVENT(2, severity::LOW);
+
+  static const size_t MAX_PATH_SIZE = 50;
+  static const size_t MAX_FILE_NAME = 30;
+
+  static const uint8_t STATUS_OFFSET = 2;
+  static const uint8_t PARAMS_OFFSET = 2;
+  static const uint8_t TICKS_OFFSET = 3;
+  static const uint8_t TIME_OFFSET = 7;
+  static const uint8_t PARAMETER_ID_OFFSET = 1;
+  static const uint8_t ACTION_ID_OFFSET = 1;
+  static const uint8_t ACTION_DATA_OFFSET = 3;
+
+  // Ping request will reply ping with this ID (data field)
+  static const uint32_t PING_ID = 0x55;
+  static const uint32_t BOOT_REGION_ID = 1;
+  static const MutexIF::TimeoutType TIMEOUT_TYPE = MutexIF::TimeoutType::WAITING;
+  static const uint32_t MUTEX_TIMEOUT = 20;
+  static const uint32_t BOOT_TIMEOUT = 1000;
+  static const uint32_t DEFAULT_TRANSITION_DELAY = 15000;
+
+  struct FlashReadCmd {
+    // Minimum length of a read command (region, length and filename)
+    static const size_t MIN_LENGTH = 7;
+  };
+
+  struct ChecksumCmd {
+    static const uint8_t ADDRESS_OFFSET = 1;
+    static const uint8_t LENGTH_OFFSET = 5;
+    // Length of checksum command
+    static const size_t LENGTH = 9;
+    uint8_t rememberRegion = 0;
+    uint32_t rememberAddress = 0;
+    uint32_t rememberLength = 0;
+  };
+
+  ChecksumCmd checksumCmd;
+
+  MessageQueueIF* eventQueue = nullptr;
+
+  startracker::TemperatureSet temperatureSet;
+  startracker::VersionSet versionSet;
+  startracker::PowerSet powerSet;
+  startracker::InterfaceSet interfaceSet;
+  startracker::TimeSet timeSet;
+  startracker::SolutionSet solutionSet;
+  startracker::HistogramSet histogramSet;
+  startracker::ChecksumSet checksumSet;
+  startracker::CameraSet cameraSet;
+  startracker::LimitsSet limitsSet;
+  startracker::LogLevelSet loglevelSet;
+  startracker::MountingSet mountingSet;
+  startracker::ImageProcessorSet imageProcessorSet;
+  startracker::CentroidingSet centroidingSet;
+  startracker::LisaSet lisaSet;
+  startracker::MatchingSet matchingSet;
+  startracker::TrackingSet trackingSet;
+  startracker::ValidationSet validationSet;
+  startracker::AlgoSet algoSet;
+  startracker::SubscriptionSet subscriptionSet;
+  startracker::LogSubscriptionSet logSubscriptionSet;
+  startracker::DebugCameraSet debugCameraSet;
+
+  // Pointer to object responsible for uploading and downloading images to/from the star tracker
+  StrComHandler* strHelper = nullptr;
+
+  uint8_t commandBuffer[startracker::MAX_FRAME_SIZE];
+
+  // Countdown to insert delay for star tracker to switch from bootloader to firmware program
+  // Loading firmware requires some time and the command will not trigger a reply when executed
+  Countdown bootCountdown;
+
+  struct JsonConfigs {
+    Tracking tracking;
+    LogLevel logLevel;
+    LogSubscription logSubscription;
+    DebugCamera debugCamera;
+    Algo algo;
+    Validation validation;
+    Matching matching;
+    Lisa lisa;
+    Centroiding centroiding;
+    Camera camera;
+    ImageProcessor imageProcessor;
+    Mounting mounting;
+    Limits limits;
+    Subscription subscription;
+  };
+  JsonConfigs jcfgs;
+  Countdown jcfgCountdown = Countdown(250);
+  bool commandExecuted = false;
+  std::thread jsonCfgTask;
+  static void setUpJsonCfgs(JsonConfigs& cfgs, const char* paramJsonFile);
+
+  std::string paramJsonFile;
+
+  enum class NormalState { TEMPERATURE_REQUEST, SOLUTION_REQUEST };
+
+  NormalState normalState = NormalState::TEMPERATURE_REQUEST;
+
+  enum class StartupState {
+    IDLE,
+    CHECK_PROGRAM,
+    WAIT_CHECK_PROGRAM,
+    BOOT_BOOTLOADER,
+    WAIT_JCFG,
+    DONE
+  };
+  StartupState startupState = StartupState::IDLE;
+
+  enum class InternalState {
+    IDLE,
+    BOOT_FIRMWARE,
+    DONE,
+    FAILED_FIRMWARE_BOOT,
+    BOOT_BOOTLOADER,
+    BOOTLOADER_CHECK,
+    FAILED_BOOTLOADER_BOOT
+  };
+
+  enum class FwBootState {
+    NONE,
+    BOOT_DELAY,
+    REQ_VERSION,
+    VERIFY_BOOT,
+    LOGLEVEL,
+    LIMITS,
+    TRACKING,
+    MOUNTING,
+    IMAGE_PROCESSOR,
+    CAMERA,
+    BLOB,
+    CENTROIDING,
+    LISA,
+    MATCHING,
+    VALIDATION,
+    ALGO,
+    LOG_SUBSCRIPTION,
+    DEBUG_CAMERA,
+    WAIT_FOR_EXECUTION,
+  };
+  FwBootState bootState = FwBootState::NONE;
+
+  InternalState internalState = InternalState::IDLE;
+
+  bool strHelperHandlingSpecialRequest = false;
+
+  const power::Switch_t powerSwitch = power::NO_SWITCH;
+
+  /**
+   * @brief   Handles internal state
+   */
+  void handleInternalState();
+
+  /**
+   * @brief   Checks mode for commands requiring MODE_ON of MODE_NORMAL for execution.
+   *
+   * @param actionId  Action id of command to execute
+   */
+  ReturnValue_t checkMode(ActionId_t actionId);
+
+  /**
+   * @brief   This function initializes the serial link ip protocol struct slipInfo.
+   */
+  void slipInit();
+
+  ReturnValue_t scanForActionReply(uint8_t replyId, DeviceCommandId_t* foundId);
+  ReturnValue_t scanForSetParameterReply(uint8_t replyId, DeviceCommandId_t* foundId);
+  ReturnValue_t scanForGetParameterReply(uint8_t replyId, DeviceCommandId_t* foundId);
+  ReturnValue_t scanForTmReply(uint8_t replyId, DeviceCommandId_t* foundId);
+
+  /**
+   * @brief   Fills command buffer with data to ping the star tracker
+   */
+  void preparePingRequest();
+
+  /**
+   * @brief   Fills command buffer with data to request the time telemetry.
+   */
+  void prepareTimeRequest();
+
+  /**
+   * @brief    Handles all received event messages
+   */
+  void handleEvent(EventMessage* eventMessage);
+
+  /**
+   * @brief   Extracts information for flash-read-command from TC data and starts execution of
+   *          flash-read-procedure
+   *
+   * @param commandData       Pointer to received command data
+   * @param commandDataLen    Size of received command data
+   *
+   * @return  returnvalue::OK if start of execution was successful, otherwise error return value
+   */
+  ReturnValue_t executeFlashReadCommand(const uint8_t* commandData, size_t commandDataLen);
+
+  /**
+   * @brief   Fills command buffer with data to boot image (works only when star tracker is
+   *          in bootloader mode).
+   */
+  void prepareBootCommand();
+
+  /**
+   * @brief   Fills command buffer with command to get the checksum of a flash part
+   */
+  ReturnValue_t prepareChecksumCommand(const uint8_t* commandData, size_t commandDataLen);
+
+  /**
+   * @brief   Fills the command buffer with the command to take an image.
+   */
+  void prepareTakeImageCommand(const uint8_t* commandData);
+
+  /**
+   * @brief   Fills command buffer with data to request the version telemetry packet
+   */
+  void prepareVersionRequest();
+
+  /**
+   * @brief   Fills the command buffer with data to request the interface telemetry packet.
+   */
+  void prepareInterfaceRequest();
+
+  /**
+   * @brief   Fills the command buffer with data to request the power telemetry packet.
+   */
+  void preparePowerRequest();
+
+  /**
+   * @brief   Fills command buffer with data to reboot star tracker.
+   */
+  void prepareSwitchToBootloaderCmd();
+
+  /**
+   * @brief   Fills command buffer with data to subscribe to a telemetry packet.
+   *
+   * @param tmId  The ID of the telemetry packet to subscribe to
+   */
+  void prepareSubscriptionCommand(const uint8_t* tmId);
+
+  /**
+   * @brief   Fills command buffer with data to request solution telemtry packet (contains
+   *          attitude information)
+   */
+  void prepareSolutionRequest();
+
+  /**
+   * @brief   Fills command buffer with data to request temperature from star tracker
+   */
+  void prepareTemperatureRequest();
+
+  /**
+   * @brief   Fills command buffer with data to request histogram
+   */
+  void prepareHistogramRequest();
+
+  /**
+   * @brief   Reads parameters from json file specified by string in commandData and
+   *          prepares the command to apply the parameter set to the star tracker
+   *
+   * @param commandData       Contains string with file name
+   * @param commandDataLen    Length of command
+   * @param paramSet          The object defining the command generation
+   *
+   * @return  returnvalue::OK if successful, otherwise error return Value
+   */
+  ReturnValue_t prepareParamCommand(const uint8_t* commandData, size_t commandDataLen,
+                                    ArcsecJsonParamBase& paramSet);
+
+  /**
+   * @brief   The following function will fill the command buffer with the command to request
+   *          a parameter set.
+   */
+  ReturnValue_t prepareRequestCameraParams();
+  ReturnValue_t prepareRequestLimitsParams();
+  ReturnValue_t prepareRequestLogLevelParams();
+  ReturnValue_t prepareRequestMountingParams();
+  ReturnValue_t prepareRequestImageProcessorParams();
+  ReturnValue_t prepareRequestCentroidingParams();
+  ReturnValue_t prepareRequestLisaParams();
+  ReturnValue_t prepareRequestMatchingParams();
+  ReturnValue_t prepareRequestTrackingParams();
+  ReturnValue_t prepareRequestValidationParams();
+  ReturnValue_t prepareRequestAlgoParams();
+  ReturnValue_t prepareRequestSubscriptionParams();
+  ReturnValue_t prepareRequestLogSubscriptionParams();
+  ReturnValue_t prepareRequestDebugCameraParams();
+
+  /**
+   * @brief   Handles action replies with datasets.
+   */
+  ReturnValue_t handleActionReplySet(const uint8_t* rawFrame, LocalPoolDataSetBase& dataset,
+                                     size_t size);
+
+  /**
+   * @brief   Default function to handle action replies
+   */
+  ReturnValue_t handleActionReply(const uint8_t* rawFrame);
+
+  /**
+   * @brief   Handles reply to upload centroid command
+   */
+  ReturnValue_t handleUploadCentroidReply();
+
+  /**
+   * @brief   Handles reply to checksum command
+   */
+  ReturnValue_t handleChecksumReply(const uint8_t* rawFrame);
+
+  /**
+   * @brief   Handles all set parameter replies
+   */
+  ReturnValue_t handleSetParamReply(const uint8_t* rawFrame);
+
+  ReturnValue_t handlePingReply(const uint8_t* rawFrame);
+
+  ReturnValue_t handleParamRequest(const uint8_t* rawFrame, LocalPoolDataSetBase& dataset,
+                                   size_t size);
+
+  /**
+   * @brief   Checks the loaded program by means of the version set
+   */
+  ReturnValue_t checkProgram();
+
+  /**
+   * @brief   Handles the startup state machine
+   */
+  void handleStartup(uint8_t parameterId);
+
+  /**
+   * @brief   Handles telemtry replies and fills the appropriate dataset
+   *
+   * @param dataset   Dataset where reply data will be written to
+   * @param size      Size of the dataset
+   *
+   * @return  returnvalue::OK if successful, otherwise error return value
+   */
+  ReturnValue_t handleTm(const uint8_t* rawFrame, LocalPoolDataSetBase& dataset, size_t size);
+
+  /**
+   * @brief Checks if star tracker is in valid mode for executing the received command.
+   *
+   * @param actioId Id of received command
+   *
+   * @return    returnvalue::OK if star tracker is in valid mode, otherwise error return value
+   */
+  ReturnValue_t checkCommand(ActionId_t actionId);
+
+  void doOnTransition(Submode_t subModeFrom);
+  void doNormalTransition(Mode_t modeFrom, Submode_t subModeFrom);
+  void bootFirmware(Mode_t toMode);
+  void bootBootloader();
+};
+
+#endif /* MISSION_DEVICES_STARTRACKERHANDLER_H_ */

linux/acs/startracker/StrComHandler.cpp

@@ -0,0 +1,784 @@
+#include "StrComHandler.h"
+
+#include <fcntl.h>
+#include <fsfw/filesystem/HasFileSystemIF.h>
+#include <fsfw/tasks/TaskFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
+#include <unistd.h>
+
+#include <filesystem>
+#include <fstream>
+
+#include "OBSWConfig.h"
+#include "eive/definitions.h"
+#include "fsfw/timemanager/Countdown.h"
+#include "helpers.h"
+#include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
+#include "mission/utility/Filenaming.h"
+#include "mission/utility/ProgressPrinter.h"
+#include "mission/utility/Timestamp.h"
+
+using namespace returnvalue;
+
+StrComHandler::StrComHandler(object_id_t objectId) : SystemObject(objectId) {
+  lock = MutexFactory::instance()->createMutex();
+  semaphore.acquire();
+}
+
+StrComHandler::~StrComHandler() {}
+
+ReturnValue_t StrComHandler::initialize() {
+#ifdef XIPHOS_Q7S
+  sdcMan = SdCardManager::instance();
+  if (sdcMan == nullptr) {
+    sif::warning << "StrHelper::initialize: Invalid SD Card Manager" << std::endl;
+    return returnvalue::FAILED;
+  }
+#endif
+  return returnvalue::OK;
+}
+
+ReturnValue_t StrComHandler::performOperation(uint8_t operationCode) {
+  ReturnValue_t result = returnvalue::OK;
+  while (true) {
+    lock->lockMutex();
+    state = InternalState::SLEEPING;
+    datalinkLayer.reset();
+    lock->unlockMutex();
+    semaphore.acquire();
+    switch (state) {
+      case InternalState::POLL_ONE_REPLY: {
+        // Stopwatch watch;
+        replyTimeout.setTimeout(200);
+        replyResult = readOneReply(static_cast<uint32_t>(state));
+        {
+          MutexGuard mg(lock);
+          replyWasReceived = true;
+        }
+        break;
+      }
+      case InternalState::UPLOAD_IMAGE: {
+        replyTimeout.setTimeout(200);
+        result = performImageUpload();
+        if (result == returnvalue::OK) {
+          triggerEvent(IMAGE_UPLOAD_SUCCESSFUL);
+        } else {
+          triggerEvent(IMAGE_UPLOAD_FAILED);
+        }
+        break;
+      }
+      case InternalState::DOWNLOAD_IMAGE: {
+        replyTimeout.setTimeout(200);
+        result = performImageDownload();
+        if (result == returnvalue::OK) {
+          triggerEvent(IMAGE_DOWNLOAD_SUCCESSFUL);
+        } else {
+          triggerEvent(IMAGE_DOWNLOAD_FAILED);
+        }
+        break;
+      }
+      case InternalState::FLASH_READ: {
+        replyTimeout.setTimeout(200);
+        result = performFlashRead();
+        if (result == returnvalue::OK) {
+          triggerEvent(FLASH_READ_SUCCESSFUL);
+        } else {
+          triggerEvent(FLASH_READ_FAILED);
+        }
+        break;
+      }
+      case InternalState::FIRMWARE_UPDATE: {
+        replyTimeout.setTimeout(200);
+        result = performFirmwareUpdate();
+        if (result == returnvalue::OK) {
+          triggerEvent(FIRMWARE_UPDATE_SUCCESSFUL);
+        } else {
+          triggerEvent(FIRMWARE_UPDATE_FAILED);
+        }
+        break;
+      }
+      default:
+        sif::debug << "StrHelper::performOperation: Invalid state" << std::endl;
+        break;
+    }
+  }
+}
+
+ReturnValue_t StrComHandler::startImageUpload(std::string fullname) {
+  {
+    MutexGuard mg(lock);
+    if (state != InternalState::SLEEPING) {
+      return BUSY;
+    }
+  }
+#ifdef XIPHOS_Q7S
+  ReturnValue_t result = checkPath(fullname);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+#endif
+  uploadImage.uploadFile = fullname;
+  if (not std::filesystem::exists(fullname)) {
+    return FILE_NOT_EXISTS;
+  }
+  {
+    MutexGuard mg(lock);
+    state = InternalState::UPLOAD_IMAGE;
+  }
+  semaphore.release();
+  terminate = false;
+  return returnvalue::OK;
+}
+
+ReturnValue_t StrComHandler::startImageDownload(std::string path) {
+  {
+    MutexGuard mg(lock);
+    if (state != InternalState::SLEEPING) {
+      return BUSY;
+    }
+  }
+#ifdef XIPHOS_Q7S
+  ReturnValue_t result = checkPath(path);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+#endif
+  if (not std::filesystem::exists(path)) {
+    return PATH_NOT_EXISTS;
+  }
+  downloadImage.path = path;
+  {
+    MutexGuard mg(lock);
+    state = InternalState::DOWNLOAD_IMAGE;
+  }
+  terminate = false;
+  semaphore.release();
+  return returnvalue::OK;
+}
+
+void StrComHandler::stopProcess() { terminate = true; }
+
+void StrComHandler::setDownloadImageName(std::string filename) {
+  downloadImage.filename = filename;
+}
+
+void StrComHandler::setFlashReadFilename(std::string filename) { flashRead.filename = filename; }
+
+ReturnValue_t StrComHandler::startFirmwareUpdate(std::string fullname) {
+  {
+    MutexGuard mg(lock);
+    if (state != InternalState::SLEEPING) {
+      return BUSY;
+    }
+  }
+#ifdef XIPHOS_Q7S
+  ReturnValue_t result = checkPath(fullname);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+#endif
+  flashWrite.fullname = fullname;
+  if (not std::filesystem::exists(flashWrite.fullname)) {
+    return FILE_NOT_EXISTS;
+  }
+  flashWrite.firstRegion = static_cast<uint8_t>(startracker::FirmwareRegions::FIRST);
+  flashWrite.lastRegion = static_cast<uint8_t>(startracker::FirmwareRegions::LAST);
+  {
+    MutexGuard mg(lock);
+    state = InternalState::FIRMWARE_UPDATE;
+  }
+  semaphore.release();
+  terminate = false;
+  return returnvalue::OK;
+}
+
+ReturnValue_t StrComHandler::startFlashRead(std::string path, uint8_t startRegion,
+                                            uint32_t length) {
+  {
+    MutexGuard mg(lock);
+    if (state != InternalState::SLEEPING) {
+      return BUSY;
+    }
+  }
+#ifdef XIPHOS_Q7S
+  ReturnValue_t result = checkPath(path);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+#endif
+  flashRead.path = path;
+  if (not std::filesystem::exists(flashRead.path)) {
+    return FILE_NOT_EXISTS;
+  }
+  flashRead.startRegion = startRegion;
+  flashRead.size = length;
+  {
+    MutexGuard mg(lock);
+    state = InternalState::FLASH_READ;
+  }
+  semaphore.release();
+  terminate = false;
+  return returnvalue::OK;
+}
+
+void StrComHandler::disableTimestamping() { timestamping = false; }
+
+void StrComHandler::enableTimestamping() { timestamping = true; }
+
+ReturnValue_t StrComHandler::performImageDownload() {
+#ifdef XIPHOS_Q7S
+  if (not sdcMan->getActiveSdCard()) {
+    return HasFileSystemIF::FILESYSTEM_INACTIVE;
+  }
+#endif
+  ReturnValue_t result;
+#if OBSW_DEBUG_STARTRACKER == 1
+  ProgressPrinter progressPrinter("Image download", ImageDownload::LAST_POSITION);
+#endif /* OBSW_DEBUG_STARTRACKER == 1 */
+  struct DownloadActionRequest downloadReq;
+  uint32_t size = 0;
+  uint32_t retries = 0;
+  size_t replySize = 0;
+  std::string image = Filenaming::generateAbsoluteFilename(downloadImage.path,
+                                                           downloadImage.filename, timestamping);
+  std::ofstream file(image, std::ios_base::out);
+  if (not std::filesystem::exists(image)) {
+    return FILE_CREATION_FAILED;
+  }
+  downloadReq.position = 0;
+  while (downloadReq.position < ImageDownload::LAST_POSITION) {
+    if (terminate) {
+      file.close();
+      return returnvalue::OK;
+    }
+    arc_pack_download_action_req(&downloadReq, cmdBuf.data(), &size);
+    result = sendAndRead(size, downloadReq.position);
+    if (result != returnvalue::OK) {
+      if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
+        serial::flushRxBuf(serialPort);
+        retries++;
+        continue;
+      }
+      file.close();
+      return result;
+    }
+    result = checkActionReply(replySize);
+    if (result != returnvalue::OK) {
+      if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
+        serial::flushRxBuf(serialPort);
+        retries++;
+        continue;
+      }
+      file.close();
+      return result;
+    }
+    result = checkReplyPosition(downloadReq.position);
+    if (result != returnvalue::OK) {
+      if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
+        serial::flushRxBuf(serialPort);
+        retries++;
+        continue;
+      }
+      file.close();
+      return result;
+    }
+    file.write(reinterpret_cast<const char*>(replyPtr + IMAGE_DATA_OFFSET), CHUNK_SIZE);
+#if OBSW_DEBUG_STARTRACKER == 1
+    progressPrinter.print(downloadReq.position);
+#endif /* OBSW_DEBUG_STARTRACKER == 1 */
+    downloadReq.position++;
+    retries = 0;
+  }
+  file.close();
+  return returnvalue::OK;
+}
+
+ReturnValue_t StrComHandler::performImageUpload() {
+  ReturnValue_t result = returnvalue::OK;
+  uint32_t size = 0;
+  uint32_t imageSize = 0;
+  struct UploadActionRequest uploadReq;
+  uploadReq.position = 0;
+#ifdef XIPHOS_Q7S
+  if (not sdcMan->getActiveSdCard()) {
+    return HasFileSystemIF::FILESYSTEM_INACTIVE;
+  }
+#endif
+  std::memset(&uploadReq.data, 0, sizeof(uploadReq.data));
+  if (not std::filesystem::exists(uploadImage.uploadFile)) {
+    triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast<uint32_t>(state));
+    return returnvalue::FAILED;
+  }
+  std::ifstream file(uploadImage.uploadFile, std::ifstream::binary);
+  if (file.bad()) {
+    return HasFileSystemIF::GENERIC_FILE_ERROR;
+  }
+
+  // Set position of next character to end of file input stream
+  file.seekg(0, file.end);
+  // tellg returns position of character in input stream
+  imageSize = file.tellg();
+#if OBSW_DEBUG_STARTRACKER == 1
+  ProgressPrinter progressPrinter("Image upload", imageSize);
+#endif /* OBSW_DEBUG_STARTRACKER == 1 */
+  while ((uploadReq.position + 1) * SIZE_IMAGE_PART < imageSize) {
+    if (terminate) {
+      return returnvalue::OK;
+    }
+    file.seekg(uploadReq.position * SIZE_IMAGE_PART, file.beg);
+    file.read(reinterpret_cast<char*>(uploadReq.data), SIZE_IMAGE_PART);
+    arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
+    result = sendAndRead(size, uploadReq.position);
+    if (result != returnvalue::OK) {
+      return returnvalue::FAILED;
+    }
+    result = checkActionReply(replyLen);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+#if OBSW_DEBUG_STARTRACKER == 1
+    progressPrinter.print((uploadReq.position + 1) * SIZE_IMAGE_PART);
+#endif /* OBSW_DEBUG_STARTRACKER == 1 */
+    uploadReq.position++;
+
+    // This does a bit of delaying roughly every second
+    if (uploadReq.position % 50 == 0) {
+      // Some grace time for other tasks
+      TaskFactory::delayTask(2);
+    }
+  }
+  std::memset(uploadReq.data, 0, sizeof(uploadReq.data));
+  uint32_t remainder = imageSize - uploadReq.position * SIZE_IMAGE_PART;
+  file.seekg(uploadReq.position * SIZE_IMAGE_PART, file.beg);
+  file.read(reinterpret_cast<char*>(uploadReq.data), remainder);
+  file.close();
+  uploadReq.position++;
+  arc_pack_upload_action_req(&uploadReq, cmdBuf.data(), &size);
+  result = sendAndRead(size, uploadReq.position);
+  if (result != returnvalue::OK) {
+    return returnvalue::FAILED;
+  }
+  result = checkActionReply(replyLen);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+#if OBSW_DEBUG_STARTRACKER == 1
+  progressPrinter.print((uploadReq.position + 1) * SIZE_IMAGE_PART);
+#endif /* OBSW_DEBUG_STARTRACKER == 1 */
+  return returnvalue::OK;
+}
+
+ReturnValue_t StrComHandler::performFirmwareUpdate() {
+  using namespace startracker;
+  ReturnValue_t result = returnvalue::OK;
+  result = unlockAndEraseRegions(static_cast<uint32_t>(startracker::FirmwareRegions::FIRST),
+                                 static_cast<uint32_t>(startracker::FirmwareRegions::LAST));
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = performFlashWrite();
+  return result;
+}
+
+ReturnValue_t StrComHandler::performFlashWrite() {
+#ifdef XIPHOS_Q7S
+  if (not sdcMan->getActiveSdCard()) {
+    return HasFileSystemIF::FILESYSTEM_INACTIVE;
+  }
+#endif
+  ReturnValue_t result = returnvalue::OK;
+  uint32_t size = 0;
+  uint32_t bytesWritten = 0;
+  uint32_t fileSize = 0;
+
+  struct WriteActionRequest req;
+  if (not std::filesystem::exists(flashWrite.fullname)) {
+    triggerEvent(STR_HELPER_FILE_NOT_EXISTS, static_cast<uint32_t>(state));
+    return returnvalue::FAILED;
+  }
+  std::ifstream file(flashWrite.fullname, std::ifstream::binary);
+  if (file.bad()) {
+    return returnvalue::FAILED;
+  }
+  file.seekg(0, file.end);
+  fileSize = file.tellg();
+  if (fileSize > FLASH_REGION_SIZE * (flashWrite.lastRegion - flashWrite.firstRegion)) {
+    sif::warning << "StrHelper::performFlashWrite: Invalid file" << std::endl;
+    return returnvalue::FAILED;
+  }
+#if OBSW_DEBUG_STARTRACKER == 1
+  ProgressPrinter progressPrinter("Flash write", fileSize);
+#endif /* OBSW_DEBUG_STARTRACKER == 1 */
+  uint32_t fileChunks = fileSize / CHUNK_SIZE;
+  bytesWritten = 0;
+  req.region = flashWrite.firstRegion;
+  req.length = CHUNK_SIZE;
+  for (uint32_t idx = 0; idx < fileChunks; idx++) {
+    if (terminate) {
+      return returnvalue::OK;
+    }
+    file.seekg(idx * CHUNK_SIZE, file.beg);
+    file.read(reinterpret_cast<char*>(req.data), CHUNK_SIZE);
+    if (bytesWritten + CHUNK_SIZE > FLASH_REGION_SIZE) {
+      req.region++;
+      bytesWritten = 0;
+    }
+    req.address = bytesWritten;
+    arc_pack_write_action_req(&req, cmdBuf.data(), &size);
+    result = sendAndRead(size, req.address);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = checkActionReply(replyLen);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    bytesWritten += CHUNK_SIZE;
+#if OBSW_DEBUG_STARTRACKER == 1
+    progressPrinter.print(idx * CHUNK_SIZE);
+#endif /* OBSW_DEBUG_STARTRACKER == 1 */
+    if (idx % 50 == 0) {
+      // Some grace time for other tasks
+      TaskFactory::delayTask(2);
+    }
+  }
+  uint32_t remainingBytes = fileSize - fileChunks * CHUNK_SIZE;
+  file.seekg((fileChunks - 1) * CHUNK_SIZE, file.beg);
+  file.read(reinterpret_cast<char*>(req.data), remainingBytes);
+  file.close();
+  if (bytesWritten + CHUNK_SIZE > FLASH_REGION_SIZE) {
+    req.region++;
+    bytesWritten = 0;
+  }
+  req.address = bytesWritten;
+  req.length = remainingBytes;
+  bytesWritten += remainingBytes;
+  arc_pack_write_action_req(&req, cmdBuf.data(), &size);
+  result = sendAndRead(size, req.address);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  result = checkActionReply(replyLen);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+#if OBSW_DEBUG_STARTRACKER == 1
+  progressPrinter.print(fileSize);
+#endif /* OBSW_DEBUG_STARTRACKER == 1 */
+  return returnvalue::OK;
+}
+
+ReturnValue_t StrComHandler::performFlashRead() {
+#ifdef XIPHOS_Q7S
+  if (not sdcMan->getActiveSdCard()) {
+    return HasFileSystemIF::FILESYSTEM_INACTIVE;
+  }
+#endif
+  ReturnValue_t result;
+#if OBSW_DEBUG_STARTRACKER == 1
+  ProgressPrinter progressPrinter("Flash read", flashRead.size);
+#endif /* OBSW_DEBUG_STARTRACKER == 1 */
+  struct ReadActionRequest req;
+  uint32_t bytesRead = 0;
+  uint32_t size = 0;
+  uint32_t retries = 0;
+  Timestamp timestamp;
+  std::string fullname =
+      Filenaming::generateAbsoluteFilename(flashRead.path, flashRead.filename, timestamping);
+  std::ofstream file(fullname, std::ios_base::app | std::ios_base::out);
+  if (not std::filesystem::exists(fullname)) {
+    return FILE_CREATION_FAILED;
+  }
+  req.region = flashRead.startRegion;
+  req.address = 0;
+  while (bytesRead < flashRead.size) {
+    if (terminate) {
+      return returnvalue::OK;
+    }
+    if ((flashRead.size - bytesRead) < CHUNK_SIZE) {
+      req.length = flashRead.size - bytesRead;
+    } else {
+      req.length = CHUNK_SIZE;
+    }
+    arc_pack_read_action_req(&req, cmdBuf.data(), &size);
+    result = sendAndRead(size, req.address);
+    if (result != returnvalue::OK) {
+      if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
+        serial::flushRxBuf(serialPort);
+        retries++;
+        continue;
+      }
+      file.close();
+      return result;
+    }
+    result = checkActionReply(replyLen);
+    if (result != returnvalue::OK) {
+      if (retries < CONFIG_MAX_DOWNLOAD_RETRIES) {
+        serial::flushRxBuf(serialPort);
+        retries++;
+        continue;
+      }
+      file.close();
+      return result;
+    }
+    file.write(reinterpret_cast<const char*>(replyPtr + FLASH_READ_DATA_OFFSET), req.length);
+    bytesRead += req.length;
+    req.address += req.length;
+    if (req.address >= FLASH_REGION_SIZE) {
+      req.address = 0;
+      req.region++;
+    }
+    retries = 0;
+#if OBSW_DEBUG_STARTRACKER == 1
+    progressPrinter.print(bytesRead);
+#endif /* OBSW_DEBUG_STARTRACKER == 1 */
+  }
+  file.close();
+  return returnvalue::OK;
+}
+
+ReturnValue_t StrComHandler::sendAndRead(size_t size, uint32_t failParameter) {
+  ReturnValue_t result = returnvalue::OK;
+
+  const uint8_t* sendData;
+  size_t txFrameLen = 0;
+  datalinkLayer.encodeFrame(cmdBuf.data(), size, &sendData, txFrameLen);
+  int writeResult = write(serialPort, sendData, txFrameLen);
+  if (writeResult < 0) {
+    sif::warning << "StrHelper::sendAndRead: Failed to send packet" << std::endl;
+    triggerEvent(STR_HELPER_SENDING_PACKET_FAILED, result, failParameter);
+    return returnvalue::FAILED;
+  }
+
+  return readOneReply(failParameter);
+}
+
+ReturnValue_t StrComHandler::checkActionReply(size_t replySize) {
+  uint8_t type = str::getReplyFrameType(replyPtr);
+  if (type != TMTC_ACTIONREPLY) {
+    sif::warning << "StrHelper::checkActionReply: Received reply with invalid type ID" << std::endl;
+    return INVALID_TYPE_ID;
+  }
+  uint8_t status = str::getStatusField(replyPtr);
+  if (status != ArcsecDatalinkLayer::STATUS_OK) {
+    sif::warning << "StrHelper::checkActionReply: Status failure: "
+                 << static_cast<unsigned int>(status) << std::endl;
+    return STATUS_ERROR;
+  }
+  return returnvalue::OK;
+}
+
+ReturnValue_t StrComHandler::checkReplyPosition(uint32_t expectedPosition) {
+  uint32_t receivedPosition = 0;
+  std::memcpy(&receivedPosition, replyPtr + POS_OFFSET, sizeof(receivedPosition));
+  if (receivedPosition != expectedPosition) {
+    triggerEvent(POSITION_MISMATCH, receivedPosition);
+    return returnvalue::FAILED;
+  }
+  return returnvalue::OK;
+}
+
+#ifdef XIPHOS_Q7S
+ReturnValue_t StrComHandler::checkPath(std::string name) {
+  if (name.substr(0, sizeof(config::SD_0_MOUNT_POINT)) == std::string(config::SD_0_MOUNT_POINT)) {
+    if (!sdcMan->isSdCardUsable(sd::SLOT_0)) {
+      sif::warning << "StrHelper::checkPath: SD card 0 not mounted" << std::endl;
+      return SD_NOT_MOUNTED;
+    }
+  } else if (name.substr(0, sizeof(config::SD_1_MOUNT_POINT)) ==
+             std::string(config::SD_1_MOUNT_POINT)) {
+    if (!sdcMan->isSdCardUsable(sd::SLOT_0)) {
+      sif::warning << "StrHelper::checkPath: SD card 1 not mounted" << std::endl;
+      return SD_NOT_MOUNTED;
+    }
+  }
+  return returnvalue::OK;
+}
+#endif
+
+ReturnValue_t StrComHandler::initializeInterface(CookieIF* cookie) {
+  if (cookie == nullptr) {
+    return returnvalue::FAILED;
+  }
+  SerialCookie* serCookie = dynamic_cast<SerialCookie*>(cookie);
+  if (serCookie == nullptr) {
+    return DeviceCommunicationIF::INVALID_COOKIE_TYPE;
+  }
+  // comCookie = serCookie;
+  std::string devname = serCookie->getDeviceFile();
+  /* Get file descriptor */
+  serialPort = open(devname.c_str(), O_RDWR);
+  if (serialPort < 0) {
+    sif::warning << "StrComHandler: open call failed with error [" << errno << ", "
+                 << strerror(errno) << std::endl;
+    return returnvalue::FAILED;
+  }
+  // Setting up UART parameters
+  tty.c_cflag &= ~PARENB;  // Clear parity bit
+  serial::setStopbits(tty, serCookie->getStopBits());
+  serial::setBitsPerWord(tty, BitsPerWord::BITS_8);
+  tty.c_cflag &= ~CRTSCTS;  // Disable RTS/CTS hardware flow control
+  serial::enableRead(tty);
+  serial::ignoreCtrlLines(tty);
+
+  // Use non-canonical mode and clear echo flag
+  tty.c_lflag &= ~(ICANON | ECHO);
+
+  // Non-blocking mode, use polling
+  tty.c_cc[VTIME] = 0;
+  tty.c_cc[VMIN] = 0;
+
+  serial::setBaudrate(tty, serCookie->getBaudrate());
+  if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
+    sif::warning << "ScexUartReader::initializeInterface: tcsetattr call failed with error ["
+                 << errno << ", " << strerror(errno) << std::endl;
+  }
+  // Flush received and unread data
+  tcflush(serialPort, TCIOFLUSH);
+  return returnvalue::OK;
+}
+
+ReturnValue_t StrComHandler::sendMessage(CookieIF* cookie, const uint8_t* sendData,
+                                         size_t sendLen) {
+  {
+    MutexGuard mg(lock);
+    if (state != InternalState::SLEEPING) {
+      return BUSY;
+    }
+  }
+  serial::flushRxBuf(serialPort);
+
+  const uint8_t* txFrame;
+  size_t frameLen;
+  datalinkLayer.encodeFrame(sendData, sendLen, &txFrame, frameLen);
+  ssize_t bytesWritten = write(serialPort, txFrame, frameLen);
+  if (bytesWritten != static_cast<ssize_t>(frameLen)) {
+    sif::warning << "StrComHandler: Sending packet failed" << std::endl;
+    return returnvalue::FAILED;
+  }
+  // Hacky, but the alternatives look bleak. The raw data contains the information we need
+  // and there are not too many special cases.
+  if (sendData[0] == TMTC_ACTIONREQ) {
+    // 1 is a firmware boot request and 7 is a reboot request. For both, no reply is expected.
+    if (sendData[1] == 7 or sendData[1] == 1) {
+      return returnvalue::OK;
+    }
+  }
+  {
+    MutexGuard mg(lock);
+    state = InternalState::POLL_ONE_REPLY;
+  }
+  // Unlock task to perform reply reading.
+  semaphore.release();
+  return returnvalue::OK;
+}
+
+ReturnValue_t StrComHandler::getSendSuccess(CookieIF* cookie) { return returnvalue::OK; }
+
+ReturnValue_t StrComHandler::requestReceiveMessage(CookieIF* cookie, size_t requestLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t StrComHandler::readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) {
+  // Consider it a configuration error if the task is not done with a command -> reply cycle
+  // in time.
+  bool replyWasReceived = false;
+  {
+    MutexGuard mg(lock);
+    if (state != InternalState::SLEEPING) {
+      return BUSY;
+    }
+    replyWasReceived = this->replyWasReceived;
+  }
+  if (not replyWasReceived) {
+    *size = 0;
+    return returnvalue::OK;
+  }
+  if (replyResult == returnvalue::OK) {
+    *buffer = const_cast<uint8_t*>(replyPtr);
+    *size = replyLen;
+  }
+  return replyResult;
+}
+
+ReturnValue_t StrComHandler::unlockAndEraseRegions(uint32_t from, uint32_t to) {
+  ReturnValue_t result = returnvalue::OK;
+#if OBSW_DEBUG_STARTRACKER == 1
+  ProgressPrinter progressPrinter("Unlock and erase", to - from);
+#endif /* OBSW_DEBUG_STARTRACKER == 1 */
+  struct UnlockActionRequest unlockReq;
+  struct EraseActionRequest eraseReq;
+  uint32_t size = 0;
+  for (uint32_t idx = from; idx <= to; idx++) {
+    unlockReq.region = idx;
+    unlockReq.code = startracker::region_secrets::secret[idx];
+    arc_pack_unlock_action_req(&unlockReq, cmdBuf.data(), &size);
+    result = sendAndRead(size, unlockReq.region);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    result = checkActionReply(replyLen);
+    if (result != returnvalue::OK) {
+      sif::warning << "StrHelper::unlockAndEraseRegions: Failed to unlock region with id "
+                   << static_cast<unsigned int>(unlockReq.region) << std::endl;
+      return result;
+    }
+    eraseReq.region = idx;
+    arc_pack_erase_action_req(&eraseReq, cmdBuf.data(), &size);
+    result = sendAndRead(size, eraseReq.region);
+    if (result != returnvalue::OK) {
+      sif::warning << "StrHelper::unlockAndEraseRegions: Failed to erase region with id "
+                   << static_cast<unsigned int>(eraseReq.region) << std::endl;
+      return result;
+    }
+#if OBSW_DEBUG_STARTRACKER == 1
+    progressPrinter.print(idx - from);
+#endif /* OBSW_DEBUG_STARTRACKER == 1 */
+  }
+  return result;
+}
+
+ReturnValue_t StrComHandler::handleSerialReception() {
+  ssize_t bytesRead = read(serialPort, reinterpret_cast<void*>(recBuf.data()),
+                           static_cast<unsigned int>(recBuf.size()));
+  if (bytesRead == 0) {
+    return NO_SERIAL_DATA_READ;
+  } else if (bytesRead < 0) {
+    sif::warning << "StrComHandler: read call failed with error [" << errno << ", "
+                 << strerror(errno) << "]" << std::endl;
+    return FAILED;
+  } else if (bytesRead >= static_cast<int>(recBuf.size())) {
+    sif::error << "StrComHandler: Receive buffer too small for " << bytesRead << " bytes"
+               << std::endl;
+    return FAILED;
+  } else if (bytesRead > 0) {
+    // sif::info << "Received " << bytesRead << " bytes from the STR" << std::endl;
+    // arrayprinter::print(recBuf.data(), bytesRead);
+    datalinkLayer.feedData(recBuf.data(), bytesRead);
+  }
+  return OK;
+}
+
+ReturnValue_t StrComHandler::readOneReply(uint32_t failParameter) {
+  ReturnValue_t result;
+  uint32_t nextDelayMs = 1;
+  replyTimeout.resetTimer();
+  while (true) {
+    handleSerialReception();
+    result = datalinkLayer.checkRingBufForFrame(&replyPtr, replyLen);
+    if (result == returnvalue::OK) {
+      return returnvalue::OK;
+    } else if (result != ArcsecDatalinkLayer::DEC_IN_PROGRESS) {
+      triggerEvent(STR_HELPER_DEC_ERROR, result, failParameter);
+      return DECODING_ERROR;
+    }
+    if (replyTimeout.hasTimedOut()) {
+      triggerEvent(STR_COM_REPLY_TIMEOUT, failParameter, replyTimeout.getTimeoutMs());
+      return RECEPTION_TIMEOUT;
+    }
+    TaskFactory::delayTask(nextDelayMs);
+    if (nextDelayMs < 32) {
+      nextDelayMs *= 2;
+    }
+  }
+}

linux/acs/startracker/StrComHandler.h

@@ -0,0 +1,378 @@
+#ifndef BSP_Q7S_DEVICES_STRHELPER_H_
+#define BSP_Q7S_DEVICES_STRHELPER_H_
+
+#include <string>
+
+#include "ArcsecDatalinkLayer.h"
+#include "OBSWConfig.h"
+
+#ifdef XIPHOS_Q7S
+#include "bsp_q7s/fs/SdCardManager.h"
+#endif
+
+#include "arcsec/client/generated/actionreq.h"
+#include "arcsec/common/generated/tmtcstructs.h"
+#include "fsfw/devicehandlers/CookieIF.h"
+#include "fsfw/objectmanager/SystemObject.h"
+#include "fsfw/osal/linux/BinarySemaphore.h"
+#include "fsfw/returnvalues/returnvalue.h"
+#include "fsfw/tasks/ExecutableObjectIF.h"
+#include "fsfw_hal/linux/serial/SerialComIF.h"
+
+/**
+ * @brief   Helper class for the star tracker handler to accelerate large data transfers.
+ *
+ * @author  J. Meier
+ */
+class StrComHandler : public SystemObject, public DeviceCommunicationIF, public ExecutableObjectIF {
+ public:
+  static const uint8_t INTERFACE_ID = CLASS_ID::STR_HELPER;
+
+  //! [EXPORT] : [COMMENT] SD card specified in path string not mounted
+  static const ReturnValue_t SD_NOT_MOUNTED = MAKE_RETURN_CODE(1);
+  //! [EXPORT] : [COMMENT] Specified file does not exist on filesystem
+  static const ReturnValue_t FILE_NOT_EXISTS = MAKE_RETURN_CODE(2);
+  //! [EXPORT] : [COMMENT] Specified path does not exist
+  static const ReturnValue_t PATH_NOT_EXISTS = MAKE_RETURN_CODE(3);
+  //! [EXPORT] : [COMMENT] Failed to create download image or read flash file
+  static const ReturnValue_t FILE_CREATION_FAILED = MAKE_RETURN_CODE(4);
+  //! [EXPORT] : [COMMENT] Region in flash write/read reply does not match expected region
+  static const ReturnValue_t REGION_MISMATCH = MAKE_RETURN_CODE(5);
+  //! [EXPORT] : [COMMENT] Address in flash write/read reply does not match expected address
+  static const ReturnValue_t ADDRESS_MISMATCH = MAKE_RETURN_CODE(6);
+  //! [EXPORT] : [COMMENT] Length in flash write/read reply does not match expected length
+  static const ReturnValue_t LENGTH_MISMATCH = MAKE_RETURN_CODE(7);
+  //! [EXPORT] : [COMMENT] Status field in reply signals error
+  static const ReturnValue_t STATUS_ERROR = MAKE_RETURN_CODE(8);
+  //! [EXPORT] : [COMMENT] Reply has invalid type ID (should be of action reply type)
+  static const ReturnValue_t INVALID_TYPE_ID = MAKE_RETURN_CODE(9);
+  static const ReturnValue_t RECEPTION_TIMEOUT = MAKE_RETURN_CODE(10);
+  static const ReturnValue_t DECODING_ERROR = MAKE_RETURN_CODE(11);
+
+  static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::STR_HELPER;
+
+  //! [EXPORT] : [COMMENT] Image upload failed
+  static const Event IMAGE_UPLOAD_FAILED = MAKE_EVENT(0, severity::LOW);
+  //! [EXPORT] : [COMMENT] Image download failed
+  static const Event IMAGE_DOWNLOAD_FAILED = MAKE_EVENT(1, severity::LOW);
+  //! [EXPORT] : [COMMENT] Uploading image to star tracker was successfulop
+  static const Event IMAGE_UPLOAD_SUCCESSFUL = MAKE_EVENT(2, severity::LOW);
+  //! [EXPORT] : [COMMENT] Image download was successful
+  static const Event IMAGE_DOWNLOAD_SUCCESSFUL = MAKE_EVENT(3, severity::LOW);
+  //! [EXPORT] : [COMMENT] Finished flash write procedure successfully
+  static const Event FLASH_WRITE_SUCCESSFUL = MAKE_EVENT(4, severity::LOW);
+  //! [EXPORT] : [COMMENT] Finished flash read procedure successfully
+  static const Event FLASH_READ_SUCCESSFUL = MAKE_EVENT(5, severity::LOW);
+  //! [EXPORT] : [COMMENT] Flash read procedure failed
+  static const Event FLASH_READ_FAILED = MAKE_EVENT(6, severity::LOW);
+  //! [EXPORT] : [COMMENT] Firmware update was successful
+  static const Event FIRMWARE_UPDATE_SUCCESSFUL = MAKE_EVENT(7, severity::LOW);
+  //! [EXPORT] : [COMMENT] Firmware update failed
+  static const Event FIRMWARE_UPDATE_FAILED = MAKE_EVENT(8, severity::LOW);
+  //! [EXPORT] : [COMMENT] Failed to read communication interface reply data
+  //! P1: Return code of failed communication interface read call
+  //! P1: Upload/download position for which the read call failed
+  static const Event STR_HELPER_READING_REPLY_FAILED = MAKE_EVENT(9, severity::LOW);
+  //! [EXPORT] : [COMMENT] Unexpected stop of decoding sequence
+  //! P1: Return code of failed communication interface read call
+  //! P1: Upload/download position for which the read call failed
+  static const Event STR_HELPER_COM_ERROR = MAKE_EVENT(10, severity::LOW);
+  //! [EXPORT] : [COMMENT] Star tracker did not send a valid reply for a certain timeout.
+  //! P1: Position of upload or download packet for which the packet wa sent. P2: Timeout
+  static const Event STR_COM_REPLY_TIMEOUT = MAKE_EVENT(11, severity::LOW);
+  //! [EXPORT] : [COMMENT] Error during decoding of received reply occurred
+  //! P1: Return value of decoding function
+  //! P2: Position of upload/download packet, or address of flash write/read request
+  static const Event STR_HELPER_DEC_ERROR = MAKE_EVENT(13, severity::LOW);
+  //! [EXPORT] : [COMMENT] Position mismatch
+  //! P1: The expected position and thus the position for which the image upload/download failed
+  static const Event POSITION_MISMATCH = MAKE_EVENT(14, severity::LOW);
+  //! [EXPORT] : [COMMENT] Specified file does not exist
+  //! P1: Internal state of str helper
+  static const Event STR_HELPER_FILE_NOT_EXISTS = MAKE_EVENT(15, severity::LOW);
+  //! [EXPORT] : [COMMENT] Sending packet to star tracker failed
+  //! P1: Return code of communication interface sendMessage function
+  //! P2: Position of upload/download packet, or address of flash write/read request for which
+  //! sending failed
+  static const Event STR_HELPER_SENDING_PACKET_FAILED = MAKE_EVENT(16, severity::LOW);
+  //! [EXPORT] : [COMMENT] Communication interface requesting reply failed
+  //! P1: Return code of failed request
+  //! P1: Upload/download position, or address of flash write/read request for which transmission
+  //! failed
+  static const Event STR_HELPER_REQUESTING_MSG_FAILED = MAKE_EVENT(17, severity::LOW);
+
+  StrComHandler(object_id_t objectId);
+  virtual ~StrComHandler();
+
+  ReturnValue_t initialize() override;
+  ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+
+  /**
+   * @brief   Starts sequence to upload image to star tracker
+   *
+   * @param uploadImage_  Name including absolute path of the image to upload. Must be previously
+   *                      transferred to the OBC with the CFDP protocol.
+   */
+  ReturnValue_t startImageUpload(std::string uploadImage_);
+
+  /**
+   * @brief   Calling this function initiates the download of an image from the star tracker.
+   *
+   * @param path  Path where downloaded image will be stored
+   */
+  ReturnValue_t startImageDownload(std::string path);
+
+  /**
+   * @brief   Will start the firmware update
+   *
+   * @param fullname    Full name including absolute path of file containing firmware
+   *                    update.
+   */
+  ReturnValue_t startFirmwareUpdate(std::string fullname);
+
+  /**
+   * @brief   Starts the flash read procedure
+   *
+   * @param path                 Path where file with read flash data will be created
+   * @param startRegion          Region form where to start reading
+   * @param length               Number of bytes to read from flash
+   */
+  ReturnValue_t startFlashRead(std::string path, uint8_t startRegion, uint32_t length);
+
+  /**
+   * @brief   Can be used to interrupt a running data transfer.
+   */
+  void stopProcess();
+
+  /**
+   * @brief   Changes the dafault name of downloaded images
+   */
+  void setDownloadImageName(std::string filename);
+
+  /**
+   * @brief   Sets the name of the file which will be created to store the data read from flash
+   */
+  void setFlashReadFilename(std::string filename);
+
+  /**
+   * @brief	Disables timestamp generation when new file is created
+   */
+  void disableTimestamping();
+
+  /**
+   * @brief	Enables timestamp generation when new file is created
+   */
+  void enableTimestamping();
+
+ private:
+  //! [EXPORT] : [SKIP]
+  static constexpr ReturnValue_t NO_SERIAL_DATA_READ = MAKE_RETURN_CODE(128);
+
+  // Size of one image part which can be sent per action request
+  static const size_t SIZE_IMAGE_PART = 1024;
+  static const uint32_t FLASH_REGION_SIZE = 0x20000;
+
+  struct ImageDownload {
+    static const uint32_t LAST_POSITION = 4095;
+  };
+
+  static const uint32_t MAX_POLLS = 10000;
+
+  static const uint8_t ACTION_DATA_OFFSET = 3;
+  static const uint8_t POS_OFFSET = 3;
+  static const uint8_t IMAGE_DATA_OFFSET = 6;
+  static const uint8_t FLASH_READ_DATA_OFFSET = 9;
+  static const uint8_t REGION_OFFSET = 3;
+  static const uint8_t ADDRESS_OFFSET = 4;
+  static const size_t CHUNK_SIZE = 1024;
+  static const size_t CONFIG_MAX_DOWNLOAD_RETRIES = 3;
+  static const uint32_t FLASH_ERASE_DELAY = 500;
+
+  enum class InternalState {
+    SLEEPING,
+    POLL_ONE_REPLY,
+    UPLOAD_IMAGE,
+    DOWNLOAD_IMAGE,
+    FLASH_READ,
+    FIRMWARE_UPDATE
+  };
+
+  InternalState state = InternalState::SLEEPING;
+
+  ArcsecDatalinkLayer datalinkLayer;
+
+  MutexIF *lock;
+  BinarySemaphore semaphore;
+
+  Countdown replyTimeout = Countdown(20);
+
+  struct UploadImage {
+    // Name including absolute path of image to upload
+    std::string uploadFile;
+  };
+  UploadImage uploadImage;
+
+  struct DownloadImage {
+    // Path where the downloaded image will be stored
+    std::string path;
+    // Default name of downloaded image, can be changed via command
+    std::string filename = "image.bin";
+  };
+  DownloadImage downloadImage;
+
+  struct FlashWrite {
+    // File which contains data to write when executing the flash write command
+    std::string fullname;
+    // The first region to write to
+    uint8_t firstRegion = 0;
+    // Maximum region the flash write command is allowed to write to
+    uint8_t lastRegion = 0;
+    // Will be set with the flash write command and specifies the start address where to write the
+    // flash data to
+    uint32_t address = 0;
+  };
+  FlashWrite flashWrite;
+
+  struct FlashRead {
+    // Path where the file containing the read data will be stored
+    std::string path = "";
+    // Default name of file containing the data read from flash, can be changed via command
+    std::string filename = "flashread.bin";
+    // Will be set with the flash read command
+    uint8_t startRegion = 0;
+    // Number of bytes to read from flash
+    uint32_t size = 0;
+  };
+  FlashRead flashRead;
+
+#ifdef XIPHOS_Q7S
+  SdCardManager *sdcMan = nullptr;
+#endif
+
+  std::array<uint8_t, startracker::MAX_FRAME_SIZE> cmdBuf{};
+  std::array<uint8_t, 4096> recBuf{};
+
+  bool replyWasReceived = false;
+  const uint8_t *replyPtr = nullptr;
+  size_t replyLen = 0;
+  ReturnValue_t replyResult = returnvalue::OK;
+
+  bool terminate = false;
+
+#ifdef EGSE
+  bool timestamping = false;
+#else
+  bool timestamping = true;
+#endif
+
+  int serialPort = 0;
+  struct termios tty = {};
+
+  // Queue id of raw data receiver
+  MessageQueueId_t rawDataReceiver = MessageQueueIF::NO_QUEUE;
+
+  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 handleSerialReception();
+
+  /**
+   * @brief   Performs image uploading
+   */
+  ReturnValue_t performImageUpload();
+
+  /**
+   * @brief Performs firmware update
+   *
+   * @return    returnvalue::OK if successful, otherwise error return value
+   */
+  ReturnValue_t performFirmwareUpdate();
+
+  /**
+   * @brief   Performs download of last taken image from the star tracker.
+   *
+   * @details Download is split over multiple packets transporting each a maximum of 1024 bytes.
+   *          In case the download of one position fails, the same packet will be again
+   *          requested. If the download of the packet fails CONFIG_MAX_DOWNLOAD_RETRIES times,
+   *          the download will be stopped.
+   */
+  ReturnValue_t performImageDownload();
+
+  /**
+   * @brief   Handles flash write procedure
+   *
+   * @param  ID of first region to write to
+   *
+   * @return returnvalue::OK if successful, otherwise returnvalue::FAILED
+   */
+  ReturnValue_t performFlashWrite();
+
+  /**
+   * @brief   Sends a sequence of commands to the star tracker to read larger parts from the
+   *          flash memory.
+   */
+  ReturnValue_t performFlashRead();
+
+  /**
+   * @brief   Sends packet to the star tracker and reads reply by using the communication
+   *          interface
+   * @details
+   * The reply frame is stored in the data link layer helper. A pointer to the start of the frame
+   * is assigned to the @replyPtr member of this class. The frame length will be assigned to
+   * the @replyLen member.
+   * @param size        Size of data beforehand written to the commandBuffer
+   * @param parameter   Parameter 2 of trigger event function
+   *
+   * @return  returnvalue::OK if successful, otherwise returnvalue::FAILED
+   */
+  ReturnValue_t sendAndRead(size_t size, uint32_t parameter);
+
+  /**
+   * @brief   Checks the header (type id and status fields) of the action reply
+   *
+   * @return  returnvalue::OK if reply confirms success of packet transfer, otherwise REUTRN_FAILED
+   */
+  ReturnValue_t checkActionReply(size_t replySize);
+
+  /**
+   * @brief   Checks the position field in a star tracker upload/download reply.
+   *
+   * @param expectedPosition  Value of expected position
+   *
+   * @return returnvalue::OK if received position matches expected position, otherwise
+   * returnvalue::FAILED
+   */
+  ReturnValue_t checkReplyPosition(uint32_t expectedPosition);
+
+#ifdef XIPHOS_Q7S
+  /**
+   * @brief   Checks if a path points to an sd card and whether the SD card is monuted.
+   *
+   * @return  SD_NOT_MOUNTED id SD card is not mounted, otherwise returnvalue::OK
+   */
+  ReturnValue_t checkPath(std::string name);
+#endif
+
+  /**
+   * @brief Unlocks a range of flash regions
+   *
+   * @param from    First region in range to unlock
+   * @param to      Last region in range to unlock
+   *
+   */
+  ReturnValue_t unlockAndEraseRegions(uint32_t from, uint32_t to);
+
+  /**
+   * The reply frame is stored in the data link layer helper. A pointer to the start of the frame
+   * is assigned to the @replyPtr member of this class. The frame length will be assigned to
+   * the @replyLen member.
+   * @param failParameter
+   * @return
+   */
+  ReturnValue_t readOneReply(uint32_t failParameter);
+};
+
+#endif /* BSP_Q7S_DEVICES_STRHELPER_H_ */

linux/acs/startracker/arcsecJsonKeys.h

@@ -0,0 +1,181 @@
+#ifndef BSP_Q7S_DEVICES_DEVICEDEFINITIONS_ARCSECJSONKEYS_H_
+#define BSP_Q7S_DEVICES_DEVICEDEFINITIONS_ARCSECJSONKEYS_H_
+
+/**
+ * @brief   Keys used in JSON file of ARCSEC.
+ */
+namespace arcseckeys {
+static const char PROPERTIES[] = "properties";
+static const char NAME[] = "name";
+static const char VALUE[] = "value";
+
+static const char LIMITS[] = "limits";
+static const char ACTION[] = "action";
+static const char FPGA18CURRENT[] = "FPGA18Current";
+static const char FPGA25CURRENT[] = "FPGA25Current";
+static const char FPGA10CURRENT[] = "FPGA10Current";
+static const char MCUCURRENT[] = "MCUCurrent";
+static const char CMOS21CURRENT[] = "CMOS21Current";
+static const char CMOSPIXCURRENT[] = "CMOSPixCurrent";
+static const char CMOS33CURRENT[] = "CMOS33Current";
+static const char CMOSVRESCURRENT[] = "CMOSVResCurrent";
+static const char CMOS_TEMPERATURE[] = "CMOSTemperature";
+static const char MCU_TEMPERATURE[] = "MCUTemperature";
+
+static const char MOUNTING[] = "mounting";
+static const char qw[] = "qw";
+static const char qx[] = "qx";
+static const char qy[] = "qy";
+static const char qz[] = "qz";
+
+static const char IMAGE_PROCESSOR[] = "imageprocessor";
+static const char IMAGE_PROCESSOR_MODE[] = "mode";
+static const char STORE[] = "store";
+static const char SIGNAL_THRESHOLD[] = "signalThreshold";
+static const char IMAGE_PROCESSOR_DARK_THRESHOLD[] = "darkThreshold";
+static const char BACKGROUND_COMPENSATION[] = "backgroundcompensation";
+
+static const char CAMERA[] = "camera";
+static const char MODE[] = "mode";
+static const char FOCALLENGTH[] = "focallength";
+static const char EXPOSURE[] = "exposure";
+static const char INTERVAL[] = "interval";
+static const char OFFSET[] = "offset";
+static const char PGAGAIN[] = "PGAGain";
+static const char ADCGAIN[] = "ADCGain";
+static const char REG_1[] = "reg1";
+static const char VAL_1[] = "val1";
+static const char REG_2[] = "reg2";
+static const char VAL_2[] = "val2";
+static const char REG_3[] = "reg3";
+static const char VAL_3[] = "val3";
+static const char REG_4[] = "reg4";
+static const char VAL_4[] = "val4";
+static const char REG_5[] = "reg5";
+static const char VAL_5[] = "val5";
+static const char REG_6[] = "reg6";
+static const char VAL_6[] = "val6";
+static const char REG_7[] = "reg7";
+static const char VAL_7[] = "val7";
+static const char REG_8[] = "reg8";
+static const char VAL_8[] = "val8";
+static const char FREQ_1[] = "freq1";
+
+static const char BLOB[] = "blob";
+static const char MIN_VALUE[] = "minValue";
+static const char MIN_DISTANCE[] = "minDistance";
+static const char NEIGHBOUR_DISTANCE[] = "neighbourDistance";
+static const char NEIGHBOUR_BRIGHT_PIXELS[] = "neighbourBrightPixels";
+static const char MIN_TOTAL_VALUE[] = "minTotalValue";
+static const char MAX_TOTAL_VALUE[] = "maxTotalValue";
+static const char MIN_BRIGHT_NEIGHBOURS[] = "minBrightNeighbours";
+static const char MAX_BRIGHT_NEIGHBOURS[] = "maxBrightNeighbours";
+static const char MAX_PIXEL_TO_CONSIDER[] = "maxPixelsToConsider";
+// static const char SIGNAL_THRESHOLD[] = "signalThreshold";
+static const char BLOB_DARK_THRESHOLD[] = "darkThreshold";
+static const char ENABLE_HISTOGRAM[] = "enableHistogram";
+static const char ENABLE_CONTRAST[] = "enableContrast";
+static const char BIN_MODE[] = "binMode";
+
+static const char CENTROIDING[] = "centroiding";
+static const char ENABLE_FILTER[] = "enableFilter";
+static const char MAX_QUALITY[] = "maxquality";
+static const char DARK_THRESHOLD[] = "darkthreshold";
+static const char MIN_QUALITY[] = "minquality";
+static const char MAX_INTENSITY[] = "maxintensity";
+static const char MIN_INTENSITY[] = "minintensity";
+static const char MAX_MAGNITUDE[] = "maxmagnitude";
+static const char GAUSSIAN_CMAX[] = "gaussianCmax";
+static const char GAUSSIAN_CMIN[] = "gaussianCmin";
+static const char TRANSMATRIX_00[] = "transmatrix00";
+static const char TRANSMATRIX_01[] = "transmatrix01";
+static const char TRANSMATRIX_10[] = "transmatrix10";
+static const char TRANSMATRIX_11[] = "transmatrix11";
+
+static const char LISA[] = "lisa";
+static const char LISA_MODE[] = "mode";
+static const char PREFILTER_DIST_THRESHOLD[] = "prefilterDistThreshold";
+static const char PREFILTER_ANGLE_THRESHOLD[] = "prefilterAngleThreshold";
+static const char FOV_WIDTH[] = "fov_width";
+static const char FOV_HEIGHT[] = "fov_height";
+static const char FLOAT_STAR_LIMIT[] = "float_star_limit";
+static const char CLOSE_STAR_LIMIT[] = "close_star_limit";
+static const char RATING_WEIGHT_CLOSE_STAR_COUNT[] = "rating_weight_close_star_count";
+static const char RATING_WEIGHT_FRACTION_CLOSE[] = "rating_weight_fraction_close";
+static const char RATING_WEIGHT_MEAN_SUM[] = "rating_weight_mean_sum";
+static const char RATING_WEIGHT_DB_STAR_COUNT[] = "rating_weight_db_star_count";
+static const char MAX_COMBINATIONS[] = "max_combinations";
+static const char NR_STARS_STOP[] = "nr_stars_stop";
+static const char FRACTION_CLOSE_STOP[] = "fraction_close_stop";
+
+static const char MATCHING[] = "matching";
+static const char SQUARED_DISTANCE_LIMIT[] = "squaredDistanceLimit";
+static const char SQUARED_SHIFT_LIMIT[] = "squaredShiftLimit";
+
+static const char VALIDATION[] = "validation";
+static const char STABLE_COUNT[] = "stable_count";
+static const char MAX_DIFFERENCE[] = "max_difference";
+static const char MIN_TRACKER_CONFIDENCE[] = "min_trackerConfidence";
+static const char MIN_MATCHED_STARS[] = "min_matchedStars";
+
+static const char TRACKING[] = "tracking";
+static const char THIN_LIMIT[] = "thinLimit";
+static const char OUTLIER_THRESHOLD[] = "outlierThreshold";
+static const char OUTLIER_THRESHOLD_QUEST[] = "outlierThresholdQUEST";
+static const char TRACKER_CHOICE[] = "trackerChoice";
+
+static const char ALGO[] = "algo";
+static const char L2T_MIN_CONFIDENCE[] = "l2t_minConfidence";
+static const char L2T_MIN_MATCHED[] = "l2t_minMatched";
+static const char T2L_MIN_CONFIDENCE[] = "t2l_minConfidence";
+static const char T2L_MIN_MATCHED[] = "t2l_minMatched";
+
+static const char LOGLEVEL[] = "loglevel";
+static const char LOGLEVEL1[] = "loglevel1";
+static const char LOGLEVEL2[] = "loglevel2";
+static const char LOGLEVEL3[] = "loglevel3";
+static const char LOGLEVEL4[] = "loglevel4";
+static const char LOGLEVEL5[] = "loglevel5";
+static const char LOGLEVEL6[] = "loglevel6";
+static const char LOGLEVEL7[] = "loglevel7";
+static const char LOGLEVEL8[] = "loglevel8";
+static const char LOGLEVEL9[] = "loglevel9";
+static const char LOGLEVEL10[] = "loglevel10";
+static const char LOGLEVEL11[] = "loglevel11";
+static const char LOGLEVEL12[] = "loglevel12";
+static const char LOGLEVEL13[] = "loglevel13";
+static const char LOGLEVEL14[] = "loglevel14";
+static const char LOGLEVEL15[] = "loglevel15";
+static const char LOGLEVEL16[] = "loglevel16";
+
+static const char SUBSCRIPTION[] = "subscription";
+static const char TELEMETRY_1[] = "telemetry1";
+static const char TELEMETRY_2[] = "telemetry2";
+static const char TELEMETRY_3[] = "telemetry3";
+static const char TELEMETRY_4[] = "telemetry4";
+static const char TELEMETRY_5[] = "telemetry5";
+static const char TELEMETRY_6[] = "telemetry6";
+static const char TELEMETRY_7[] = "telemetry7";
+static const char TELEMETRY_8[] = "telemetry8";
+static const char TELEMETRY_9[] = "telemetry9";
+static const char TELEMETRY_10[] = "telemetry10";
+static const char TELEMETRY_11[] = "telemetry11";
+static const char TELEMETRY_12[] = "telemetry12";
+static const char TELEMETRY_13[] = "telemetry13";
+static const char TELEMETRY_14[] = "telemetry14";
+static const char TELEMETRY_15[] = "telemetry15";
+static const char TELEMETRY_16[] = "telemetry16";
+
+static const char LOG_SUBSCRIPTION[] = "logsubscription";
+static const char LEVEL1[] = "level1";
+static const char MODULE1[] = "module1";
+static const char LEVEL2[] = "level2";
+static const char MODULE2[] = "module2";
+
+static const char DEBUG_CAMERA[] = "debugcamera";
+static const char TIMING[] = "timing";
+static const char TEST[] = "test";
+
+}  // namespace arcseckeys
+
+#endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_ARCSECJSONKEYS_H_ */

linux/acs/startracker/helpers.cpp

@@ -0,0 +1,7 @@
+#include "helpers.h"
+
+uint8_t str::getReplyFrameType(const uint8_t* rawFrame) { return rawFrame[0]; }
+
+uint8_t str::getId(const uint8_t* rawFrame) { return rawFrame[1]; }
+
+uint8_t str::getStatusField(const uint8_t* rawFrame) { return rawFrame[2]; }

linux/acs/startracker/helpers.h

@@ -0,0 +1,17 @@
+#ifndef LINUX_DEVICES_STARTRACKER_HELPERS_H_
+#define LINUX_DEVICES_STARTRACKER_HELPERS_H_
+
+#include "arcsec/common/genericstructs.h"
+
+namespace str {
+
+/**
+ * @brief    Returns the frame type field of a decoded frame.
+ */
+uint8_t getReplyFrameType(const uint8_t* rawFrame);
+uint8_t getId(const uint8_t* rawFrame);
+uint8_t getStatusField(const uint8_t* rawFrame);
+
+}  // namespace str
+
+#endif /* LINUX_DEVICES_STARTRACKER_HELPERS_H_ */

linux/acs/startracker/strJsonCommands.cpp

@@ -0,0 +1,917 @@
+#include "strJsonCommands.h"
+
+#include "arcsecJsonKeys.h"
+
+Limits::Limits() : ArcsecJsonParamBase(arcseckeys::LIMITS) {}
+
+size_t Limits::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t Limits::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::LIMITS);
+  offset = 2;
+  result = getParam(arcseckeys::ACTION, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::FPGA18CURRENT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::FPGA25CURRENT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::FPGA10CURRENT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::MCUCURRENT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::CMOS21CURRENT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::CMOSPIXCURRENT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::CMOS33CURRENT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::CMOSVRESCURRENT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::CMOS_TEMPERATURE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::MCU_TEMPERATURE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  return returnvalue::OK;
+}
+
+Tracking::Tracking() : ArcsecJsonParamBase(arcseckeys::TRACKING) {}
+
+size_t Tracking::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t Tracking::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::TRACKING);
+  offset = 2;
+  result = getParam(arcseckeys::THIN_LIMIT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::OUTLIER_THRESHOLD, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::OUTLIER_THRESHOLD_QUEST, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::TRACKER_CHOICE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  return returnvalue::OK;
+}
+
+Mounting::Mounting() : ArcsecJsonParamBase(arcseckeys::MOUNTING) {}
+
+size_t Mounting::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t Mounting::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::MOUNTING);
+  offset = 2;
+  result = getParam(arcseckeys::qw, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::qx, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::qy, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::qz, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  return returnvalue::OK;
+}
+
+ImageProcessor::ImageProcessor() : ArcsecJsonParamBase(arcseckeys::IMAGE_PROCESSOR) {}
+
+size_t ImageProcessor::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t ImageProcessor::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::IMAGE_PROCESSOR);
+  offset = 2;
+  result = getParam(arcseckeys::IMAGE_PROCESSOR_MODE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::STORE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::SIGNAL_THRESHOLD, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint16(param, buffer + offset);
+  offset += sizeof(uint16_t);
+  result = getParam(arcseckeys::IMAGE_PROCESSOR_DARK_THRESHOLD, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint16(param, buffer + offset);
+  offset += sizeof(uint16_t);
+  result = getParam(arcseckeys::BACKGROUND_COMPENSATION, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  return returnvalue::OK;
+}
+
+Camera::Camera() : ArcsecJsonParamBase(arcseckeys::CAMERA) {}
+
+size_t Camera::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t Camera::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::CAMERA);
+  offset = 2;
+  result = getParam(arcseckeys::MODE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::FOCALLENGTH, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::EXPOSURE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::INTERVAL, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::OFFSET, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addint16(param, buffer + offset);
+  offset += sizeof(int16_t);
+  result = getParam(arcseckeys::PGAGAIN, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::ADCGAIN, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::REG_1, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::VAL_1, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::REG_2, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::VAL_2, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::REG_3, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::VAL_3, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::REG_4, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::VAL_4, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::REG_5, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::VAL_5, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::REG_6, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::VAL_6, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::REG_7, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::VAL_7, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::REG_8, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::VAL_8, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::FREQ_1, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint32(param, buffer + offset);
+  return returnvalue::OK;
+}
+
+Centroiding::Centroiding() : ArcsecJsonParamBase(arcseckeys::CENTROIDING) {}
+
+size_t Centroiding::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t Centroiding::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::CENTROIDING);
+  offset = 2;
+  result = getParam(arcseckeys::ENABLE_FILTER, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::MAX_QUALITY, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::DARK_THRESHOLD, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::MIN_QUALITY, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::MAX_INTENSITY, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::MIN_INTENSITY, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::MAX_MAGNITUDE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::GAUSSIAN_CMAX, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::GAUSSIAN_CMIN, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::TRANSMATRIX_00, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::TRANSMATRIX_01, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::TRANSMATRIX_10, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::TRANSMATRIX_11, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  return returnvalue::OK;
+}
+
+Lisa::Lisa() : ArcsecJsonParamBase(arcseckeys::LISA) {}
+
+size_t Lisa::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t Lisa::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::LISA);
+  offset = 2;
+  result = getParam(arcseckeys::LISA_MODE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint32(param, buffer + offset);
+  offset += sizeof(uint32_t);
+  result = getParam(arcseckeys::PREFILTER_DIST_THRESHOLD, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::PREFILTER_ANGLE_THRESHOLD, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::FOV_WIDTH, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::FOV_HEIGHT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::FLOAT_STAR_LIMIT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::CLOSE_STAR_LIMIT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::RATING_WEIGHT_CLOSE_STAR_COUNT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::RATING_WEIGHT_FRACTION_CLOSE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::RATING_WEIGHT_MEAN_SUM, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::RATING_WEIGHT_DB_STAR_COUNT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::MAX_COMBINATIONS, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::NR_STARS_STOP, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::FRACTION_CLOSE_STOP, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  return returnvalue::OK;
+}
+
+Matching::Matching() : ArcsecJsonParamBase(arcseckeys::MATCHING) {}
+
+size_t Matching::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t Matching::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::MATCHING);
+  offset = 2;
+  result = getParam(arcseckeys::SQUARED_DISTANCE_LIMIT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::SQUARED_SHIFT_LIMIT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  return returnvalue::OK;
+}
+
+Validation::Validation() : ArcsecJsonParamBase(arcseckeys::VALIDATION) {}
+
+size_t Validation::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t Validation::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::VALIDATION);
+  offset = 2;
+  result = getParam(arcseckeys::STABLE_COUNT, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::MAX_DIFFERENCE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::MIN_TRACKER_CONFIDENCE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::MIN_MATCHED_STARS, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  return returnvalue::OK;
+}
+
+Algo::Algo() : ArcsecJsonParamBase(arcseckeys::ALGO) {}
+
+size_t Algo::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t Algo::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::ALGO);
+  offset = 2;
+  result = getParam(arcseckeys::MODE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::L2T_MIN_CONFIDENCE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::L2T_MIN_MATCHED, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::T2L_MIN_CONFIDENCE, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  addfloat(param, buffer + offset);
+  offset += sizeof(float);
+  result = getParam(arcseckeys::T2L_MIN_MATCHED, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  return returnvalue::OK;
+}
+
+LogLevel::LogLevel() : ArcsecJsonParamBase(arcseckeys::LOGLEVEL) {}
+
+size_t LogLevel::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t LogLevel::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::LOG_LEVEL);
+  offset = 2;
+  result = getParam(arcseckeys::LOGLEVEL1, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL2, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL3, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL4, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL5, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL6, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL7, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL8, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL9, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL10, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL11, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL12, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL13, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL14, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL15, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LOGLEVEL16, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+
+  return returnvalue::OK;
+}
+
+Subscription::Subscription() : ArcsecJsonParamBase(arcseckeys::SUBSCRIPTION) {}
+
+size_t Subscription::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t Subscription::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::SUBSCRIPTION);
+  offset = 2;
+  result = getParam(arcseckeys::TELEMETRY_1, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_2, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_3, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_4, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_5, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_6, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_7, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_8, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_9, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_10, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_11, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_12, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_13, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_14, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_15, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::TELEMETRY_16, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  return returnvalue::OK;
+}
+
+LogSubscription::LogSubscription() : ArcsecJsonParamBase(arcseckeys::LOG_SUBSCRIPTION) {}
+
+size_t LogSubscription::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t LogSubscription::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::LOG_SUBSCRIPTION);
+  offset = 2;
+  result = getParam(arcseckeys::LEVEL1, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::MODULE1, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::LEVEL2, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  offset += sizeof(uint8_t);
+  result = getParam(arcseckeys::MODULE2, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint8(param, buffer + offset);
+  return returnvalue::OK;
+}
+
+DebugCamera::DebugCamera() : ArcsecJsonParamBase(arcseckeys::DEBUG_CAMERA) {}
+
+size_t DebugCamera::getSize() { return COMMAND_SIZE; }
+
+ReturnValue_t DebugCamera::createCommand(uint8_t* buffer) {
+  ReturnValue_t result = returnvalue::OK;
+  uint8_t offset = 0;
+  std::string param;
+  addSetParamHeader(buffer, startracker::ID::DEBUG_CAMERA);
+  offset = 2;
+  result = getParam(arcseckeys::TIMING, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint32(param, buffer + offset);
+  offset += sizeof(uint32_t);
+  result = getParam(arcseckeys::TEST, param);
+  if (result != returnvalue::OK) {
+    return result;
+  }
+  adduint32(param, buffer + offset);
+  return returnvalue::OK;
+}

linux/acs/startracker/strJsonCommands.h

@@ -0,0 +1,240 @@
+#ifndef BSP_Q7S_DEVICES_DEVICEDEFINITIONS_STARTRACKERJSONCOMMANDS_H_
+#define BSP_Q7S_DEVICES_DEVICEDEFINITIONS_STARTRACKERJSONCOMMANDS_H_
+
+/**
+ * @brief   This file defines a few helper classes to generate commands by means of the parameters
+ *          defined in the arcsec json files.
+ *  @author J. Meier
+ */
+
+#include <string>
+
+#include "ArcsecJsonParamBase.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+
+/**
+ * @brief   Generates command to set the limit parameters
+ *
+ */
+class Limits : public ArcsecJsonParamBase {
+ public:
+  Limits();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 43;
+
+  virtual ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+/**
+ * @brief   Generates the command to configure the tracking algorithm.
+ *
+ */
+class Tracking : public ArcsecJsonParamBase {
+ public:
+  Tracking();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 15;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+/**
+ * @brief   Generates the command to set the mounting quaternion
+ *
+ */
+class Mounting : public ArcsecJsonParamBase {
+ public:
+  Mounting();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 18;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+/**
+ * @brief   Generates the command to configure the image processor
+ *
+ */
+class ImageProcessor : public ArcsecJsonParamBase {
+ public:
+  ImageProcessor();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 9;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+/**
+ * @brief   Generates the command to set the mounting quaternion
+ *
+ */
+class Camera : public ArcsecJsonParamBase {
+ public:
+  Camera();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 39;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+/**
+ * @brief   Generates the command to configure the centroiding algorithm
+ *
+ */
+class Centroiding : public ArcsecJsonParamBase {
+ public:
+  Centroiding();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 51;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+/**
+ * @brief   Generates the command to configure the LISA (lost in space algorithm)
+ *
+ */
+class Lisa : public ArcsecJsonParamBase {
+ public:
+  Lisa();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 52;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+/**
+ * @brief   Generates the command to configure the matching algorithm
+ *
+ */
+class Matching : public ArcsecJsonParamBase {
+ public:
+  Matching();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 10;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+/**
+ * @brief   Generates the command to configure the validation parameters
+ *
+ */
+class Validation : public ArcsecJsonParamBase {
+ public:
+  Validation();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 12;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+/**
+ * @brief   Generates command to configure the mechanism of automatically switching between the
+ *          LISA and other algorithms.
+ *
+ */
+class Algo : public ArcsecJsonParamBase {
+ public:
+  Algo();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 13;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+/**
+ * @brief   Generates command to configure the log level parameters.
+ *
+ */
+class LogLevel : public ArcsecJsonParamBase {
+ public:
+  LogLevel();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 18;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+/**
+ * @brief   Generates command to set subscription parameters.
+ *
+ */
+class Subscription : public ArcsecJsonParamBase {
+ public:
+  Subscription();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 18;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+/**
+ * @brief   Generates command to set log subscription parameters.
+ *
+ */
+class LogSubscription : public ArcsecJsonParamBase {
+ public:
+  LogSubscription();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 6;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+/**
+ * @brief   Generates command to set debug camera parameters
+ *
+ */
+class DebugCamera : public ArcsecJsonParamBase {
+ public:
+  DebugCamera();
+
+  size_t getSize();
+
+ private:
+  static const size_t COMMAND_SIZE = 10;
+
+  ReturnValue_t createCommand(uint8_t* buffer) override;
+};
+
+#endif /* BSP_Q7S_DEVICES_DEVICEDEFINITIONS_STARTRACKERJSONCOMMANDS_H_ */