rework SUS polling

linux/devices/AcsBoardPolling.h

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

linux/devices/CMakeLists.txt

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

linux/devices/SusPolling.cpp

@@ -0,0 +1,109 @@
+#include "SusPolling.h"
+
+#include <fsfw/tasks/SemaphoreFactory.h>
+#include <fsfw_hal/linux/spi/SpiCookie.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();
+    // TODO: Perform SUS polling here.
+  }
+  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);
+  if (susDevs[susIdx].mode != susReq->mode) {
+  }
+  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) {
+  return OK;
+}
+
+int SusPolling::addressToIndex(address_t addr) {
+  switch (addr) {
+    case (addresses::SUS_0):
+      return 0;
+      break;
+    case (addresses::SUS_1):
+      return 1;
+      break;
+    case (addresses::SUS_2):
+      return 2;
+      break;
+    case (addresses::SUS_3):
+      return 3;
+      break;
+    case (addresses::SUS_4):
+      return 4;
+      break;
+    case (addresses::SUS_5):
+      return 5;
+      break;
+    case (addresses::SUS_6):
+      return 6;
+      break;
+    case (addresses::SUS_7):
+      return 7;
+      break;
+    case (addresses::SUS_8):
+      return 8;
+      break;
+    case (addresses::SUS_9):
+      return 9;
+      break;
+    case (addresses::SUS_10):
+      return 10;
+      break;
+    case (addresses::SUS_11):
+      return 11;
+      break;
+    default: {
+      return -1;
+    }
+  }
+}

linux/devices/SusPolling.h

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