RW Refactoring

- FSFW update: SPI device is part of ComIF now - Only set RW mode (speed is set a side effect but not necessary) once - Release SPI bus in the 70 ms delay duration
2022-05-11 11:13:00 +02:00 · 2022-05-11 11:13:00 +02:00 · c043375ae3
commit c043375ae3
parent cf98d446f9
7 changed files with 117 additions and 84 deletions
--- a/bsp_q7s/callbacks/rwSpiCallback.cpp
+++ b/bsp_q7s/callbacks/rwSpiCallback.cpp
@ -10,6 +10,22 @@

 namespace rwSpiCallback {

+namespace {
+static bool MODE_SET = false;
+
+ReturnValue_t openSpi(const std::string& devname, int flags, GpioIF* gpioIF, gpioId_t gpioId,
+                      MutexIF* mutex, MutexIF::TimeoutType timeoutType, uint32_t timeoutMs,
+                      int& fd);
+/**
+ * @brief   This function closes a spi session. Pulls the chip select to high an releases the
+ *          mutex.
+ * @param gpioId    Gpio ID of chip select
+ * @param gpioIF    Pointer to gpio interface to drive the chip select
+ * @param mutex     The spi mutex
+ */
+void closeSpi(gpioId_t gpioId, GpioIF* gpioIF, MutexIF* mutex);
+}  // namespace
+
 ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sendData,
                          size_t sendLen, void* args) {
  // Stopwatch watch;
@ -35,34 +51,27 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
  }

  int fileDescriptor = 0;
-  std::string device = cookie->getSpiDevice();
-  UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "rwSpiCallback::spiCallback");
-  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "rwSpiCallback::spiCallback: Failed to open device file" << std::endl;
-    return SpiComIF::OPENING_FILE_FAILED;
-  }
-  spi::SpiModes spiMode = spi::SpiModes::MODE_0;
-  uint32_t spiSpeed = 0;
-  cookie->getSpiParameters(spiMode, spiSpeed, nullptr);
-  comIf->setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
-
-  result = mutex->lockMutex(timeoutType, timeoutMs);
+  const std::string& dev = comIf->getSpiDev();
+  result = openSpi(dev, O_RDWR, gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
  if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::debug << "rwSpiCallback::spiCallback: Failed to lock mutex" << std::endl;
    return result;
  }

-  /** Sending frame start sign */
-  writeBuffer[0] = 0x7E;
-  writeSize = 1;
-
-  // Pull SPI CS low. For now, no support for active high given
-  if (gpioId != gpio::NO_GPIO) {
-    if (gpioIF->pullLow(gpioId) != HasReturnvaluesIF::RETURN_OK) {
-      sif::error << "rwSpiCallback::spiCallback: Failed to pull chip select low" << std::endl;
-    }
+  spi::SpiModes spiMode = spi::SpiModes::MODE_0;
+  uint32_t spiSpeed = 0;
+  cookie->getSpiParameters(spiMode, spiSpeed, nullptr);
+  // We are in protected section, so we can use the static variable here without issues.
+  // 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 MODE_SET) {
+    comIf->setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
+    MODE_SET = true;
  }

+  /** Sending frame start sign */
+  writeBuffer[0] = FLAG_BYTE;
+  writeSize = 1;
+
  if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
    sif::error << "rwSpiCallback::spiCallback: Write failed!" << std::endl;
    closeSpi(gpioId, gpioIF, mutex);
@ -97,7 +106,7 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
  }

  /** Sending frame end sign */
-  writeBuffer[0] = 0x7E;
+  writeBuffer[0] = FLAG_BYTE;
  writeSize = 1;

  if (write(fileDescriptor, writeBuffer, writeSize) != static_cast<ssize_t>(writeSize)) {
@ -115,8 +124,14 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen

  size_t replyBufferSize = cookie->getMaxBufferSize();

-  /** There must be a delay of at least 20 ms after sending the command */
+  // There must be a delay of at least 20 ms after sending the command.
+  // Delay for 70 ms here and release the SPI bus for that duration.
+  closeSpi(gpioId, gpioIF, mutex);
  usleep(RwDefinitions::SPI_REPLY_DELAY);
+  result = openSpi(dev, O_RDWR, gpioIF, gpioId, mutex, timeoutType, timeoutMs, fileDescriptor);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }

  /**
   * The reaction wheel responds with empty frames while preparing the reply data.
@ -204,8 +219,9 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
        result = RwHandler::SPI_READ_FAILURE;
        break;
      }
-      if (byteRead != 0x7E) {
-        sif::error << "rwSpiCallback::spiCallback: Missing end sign 0x7E" << std::endl;
+      if (byteRead != FLAG_BYTE) {
+        sif::error << "rwSpiCallback::spiCallback: Missing end sign " << static_cast<int>(FLAG_BYTE)
+                   << std::endl;
        decodedFrameLen--;
        result = RwHandler::MISSING_END_SIGN;
        break;
@ -221,6 +237,33 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
  return result;
 }

+namespace {
+
+ReturnValue_t openSpi(const std::string& devname, int flags, GpioIF* gpioIF, gpioId_t gpioId,
+                      MutexIF* mutex, MutexIF::TimeoutType timeoutType, uint32_t timeoutMs,
+                      int& fd) {
+  ReturnValue_t result = mutex->lockMutex(timeoutType, timeoutMs);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::debug << "rwSpiCallback::spiCallback: Failed to lock mutex" << std::endl;
+    return result;
+  }
+
+  fd = open(devname.c_str(), flags);
+  if (fd < 0) {
+    sif::error << "rwSpiCallback::spiCallback: Failed to open device file" << std::endl;
+    return SpiComIF::OPENING_FILE_FAILED;
+  }
+
+  // Pull SPI CS low. For now, no support for active high given
+  if (gpioId != gpio::NO_GPIO) {
+    result = gpioIF->pullLow(gpioId);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      sif::error << "rwSpiCallback::spiCallback: Failed to pull chip select low" << std::endl;
+      return result;
+    }
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
 void closeSpi(gpioId_t gpioId, GpioIF* gpioIF, MutexIF* mutex) {
  if (gpioId != gpio::NO_GPIO) {
    if (gpioIF->pullHigh(gpioId) != HasReturnvaluesIF::RETURN_OK) {
@ -232,4 +275,7 @@ void closeSpi(gpioId_t gpioId, GpioIF* gpioIF, MutexIF* mutex) {
    ;
  }
 }
+
+}  // namespace
+
 }  // namespace rwSpiCallback
--- a/bsp_q7s/callbacks/rwSpiCallback.h
+++ b/bsp_q7s/callbacks/rwSpiCallback.h
@ -33,14 +33,5 @@ static constexpr uint8_t FLAG_BYTE = 0x7E;
 ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sendData,
                          size_t sendLen, void* args);

-/**
- * @brief   This function closes a spi session. Pulls the chip select to high an releases the
- *          mutex.
- * @param gpioId    Gpio ID of chip select
- * @param gpioIF    Pointer to gpio interface to drive the chip select
- * @param mutex     The spi mutex
- */
-void closeSpi(gpioId_t gpioId, GpioIF* gpioIF, MutexIF* mutex);
-
 }  // namespace rwSpiCallback
 #endif /* BSP_Q7S_RW_SPI_CALLBACK_H_ */
--- a/bsp_q7s/core/ObjectFactory.cpp
+++ b/bsp_q7s/core/ObjectFactory.cpp
@ -150,8 +150,8 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, Ua
  new CspComIF(objects::CSP_COM_IF);
  *i2cComIF = new I2cComIF(objects::I2C_COM_IF);
  *uartComIF = new UartComIF(objects::UART_COM_IF);
-  *spiMainComIF = new SpiComIF(objects::SPI_MAIN_COM_IF, *gpioComIF);
-  *spiRWComIF = new SpiComIF(objects::SPI_RW_COM_IF, *gpioComIF);
+  *spiMainComIF = new SpiComIF(objects::SPI_MAIN_COM_IF, q7s::SPI_DEFAULT_DEV, *gpioComIF);
+  *spiRWComIF = new SpiComIF(objects::SPI_RW_COM_IF, q7s::SPI_RW_DEV, *gpioComIF);
  /* Adding gpios for chip select decoding to the gpioComIf */
  q7s::gpioCallbacks::initSpiCsDecoder(*gpioComIF);
 }
@ -211,9 +211,9 @@ void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
  gpioCookieRadSensor->addGpio(gpioIds::ENABLE_RADFET, gpio);
  gpioChecker(gpioComIF->addGpios(gpioCookieRadSensor), "RAD sensor");

-  SpiCookie* spiCookieRadSensor = new SpiCookie(
-      addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, std::string(q7s::SPI_DEFAULT_DEV),
-      RAD_SENSOR::READ_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
+  SpiCookie* spiCookieRadSensor =
+      new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, RAD_SENSOR::READ_SIZE,
+                    spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
  auto radSensor = new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_MAIN_COM_IF,
                                              spiCookieRadSensor, gpioComIF);
  static_cast<void>(radSensor);
@ -332,8 +332,8 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
 #if OBSW_ADD_ACS_HANDLERS == 1
  std::string spiDev = q7s::SPI_DEFAULT_DEV;
  SpiCookie* spiCookie =
-      new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, spiDev,
-                    MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
+      new SpiCookie(addresses::MGM_0_LIS3, gpioIds::MGM_0_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
+                    spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
  auto mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_0_LIS3_HANDLER, objects::SPI_MAIN_COM_IF,
                                              spiCookie, spi::LIS3_TRANSITION_DELAY);
  fdir = new AcsBoardFdir(objects::MGM_0_LIS3_HANDLER);
@ -347,8 +347,8 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
  mgmLis3Handler->enablePeriodicPrintouts(true, 10);
 #endif
  spiCookie =
-      new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, spiDev,
-                    RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
+      new SpiCookie(addresses::MGM_1_RM3100, gpioIds::MGM_1_RM3100_CS, RM3100::MAX_BUFFER_SIZE,
+                    spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
  auto mgmRm3100Handler =
      new MgmRM3100Handler(objects::MGM_1_RM3100_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
                           spi::RM3100_TRANSITION_DELAY);
@ -364,8 +364,8 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
  mgmRm3100Handler->enablePeriodicPrintouts(true, 10);
 #endif
  spiCookie =
-      new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, spiDev,
-                    MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
+      new SpiCookie(addresses::MGM_2_LIS3, gpioIds::MGM_2_LIS3_CS, MGMLIS3MDL::MAX_BUFFER_SIZE,
+                    spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
  mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_2_LIS3_HANDLER, objects::SPI_MAIN_COM_IF,
                                         spiCookie, spi::LIS3_TRANSITION_DELAY);
  fdir = new AcsBoardFdir(objects::MGM_2_LIS3_HANDLER);
@ -380,8 +380,8 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
  mgmLis3Handler->enablePeriodicPrintouts(true, 10);
 #endif
  spiCookie =
-      new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, spiDev,
-                    RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
+      new SpiCookie(addresses::MGM_3_RM3100, gpioIds::MGM_3_RM3100_CS, RM3100::MAX_BUFFER_SIZE,
+                    spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
  mgmRm3100Handler = new MgmRM3100Handler(objects::MGM_3_RM3100_HANDLER, objects::SPI_MAIN_COM_IF,
                                          spiCookie, spi::RM3100_TRANSITION_DELAY);
  fdir = new AcsBoardFdir(objects::MGM_3_RM3100_HANDLER);
@ -396,9 +396,9 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
 #endif
  // Commented until ACS board V2 in in clean room again
  // Gyro 0 Side A
-  spiCookie = new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, spiDev,
-                            ADIS1650X::MAXIMUM_REPLY_SIZE, spi::DEFAULT_ADIS16507_MODE,
-                            spi::DEFAULT_ADIS16507_SPEED);
+  spiCookie =
+      new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, ADIS1650X::MAXIMUM_REPLY_SIZE,
+                    spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED);
  auto adisHandler =
      new GyroADIS1650XHandler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie,
                               ADIS1650X::Type::ADIS16505);
@ -414,9 +414,8 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
  adisHandler->enablePeriodicPrintouts(true, 10);
 #endif
  // Gyro 1 Side A
-  spiCookie =
-      new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, spiDev, L3GD20H::MAX_BUFFER_SIZE,
-                    spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+  spiCookie = new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, L3GD20H::MAX_BUFFER_SIZE,
+                            spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
  auto gyroL3gHandler = new GyroHandlerL3GD20H(
      objects::GYRO_1_L3G_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, spi::L3G_TRANSITION_DELAY);
  fdir = new AcsBoardFdir(objects::GYRO_1_L3G_HANDLER);
@ -431,9 +430,9 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
  gyroL3gHandler->enablePeriodicPrintouts(true, 10);
 #endif
  // Gyro 2 Side B
-  spiCookie = new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, spiDev,
-                            ADIS1650X::MAXIMUM_REPLY_SIZE, spi::DEFAULT_ADIS16507_MODE,
-                            spi::DEFAULT_ADIS16507_SPEED);
+  spiCookie =
+      new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, ADIS1650X::MAXIMUM_REPLY_SIZE,
+                    spi::DEFAULT_ADIS16507_MODE, spi::DEFAULT_ADIS16507_SPEED);
  adisHandler = new GyroADIS1650XHandler(objects::GYRO_2_ADIS_HANDLER, objects::SPI_MAIN_COM_IF,
                                         spiCookie, ADIS1650X::Type::ADIS16505);
  fdir = new AcsBoardFdir(objects::GYRO_2_ADIS_HANDLER);
@ -444,9 +443,8 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
  adisHandler->setToGoToNormalModeImmediately();
 #endif
  // Gyro 3 Side B
-  spiCookie =
-      new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, spiDev, L3GD20H::MAX_BUFFER_SIZE,
-                    spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+  spiCookie = new SpiCookie(addresses::GYRO_3_L3G, gpioIds::GYRO_3_L3G_CS, L3GD20H::MAX_BUFFER_SIZE,
+                            spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
  gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_3_L3G_HANDLER, objects::SPI_MAIN_COM_IF,
                                          spiCookie, spi::L3G_TRANSITION_DELAY);
  fdir = new AcsBoardFdir(objects::GYRO_3_L3G_HANDLER);
@ -661,8 +659,8 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF,
  std::array<RwHandler*, 4> rws = {};
  for (uint8_t idx = 0; idx < rwCookies.size(); idx++) {
    rwCookies[idx] = new SpiCookie(rwCookieParams[idx].first, rwCookieParams[idx].second,
-                                   q7s::SPI_RW_DEV, RwDefinitions::MAX_REPLY_SIZE, spi::RW_MODE,
-                                   spi::RW_SPEED, &rwSpiCallback::spiCallback, nullptr);
+                                   RwDefinitions::MAX_REPLY_SIZE, spi::RW_MODE, spi::RW_SPEED,
+                                   &rwSpiCallback::spiCallback, nullptr);
    rws[idx] = new RwHandler(rwIds[idx], objects::SPI_RW_COM_IF, rwCookies[idx], gpioComIF,
                             rwGpioIds[idx]);
    rwCookies[idx]->setCallbackArgs(rws[idx]);
@ -837,9 +835,9 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF*
                                    gpio::Levels::HIGH);
  plPcduGpios->addGpio(gpioIds::PLPCDU_ADC_CS, gpio);
  gpioChecker(gpioComIF->addGpios(plPcduGpios), "PL PCDU");
-  SpiCookie* spiCookie = new SpiCookie(addresses::PLPCDU_ADC, gpioIds::PLPCDU_ADC_CS,
-                                       q7s::SPI_DEFAULT_DEV, plpcdu::MAX_ADC_REPLY_SIZE,
-                                       spi::DEFAULT_MAX_1227_MODE, spi::PL_PCDU_MAX_1227_SPEED);
+  SpiCookie* spiCookie =
+      new SpiCookie(addresses::PLPCDU_ADC, gpioIds::PLPCDU_ADC_CS, plpcdu::MAX_ADC_REPLY_SIZE,
+                    spi::DEFAULT_MAX_1227_MODE, spi::PL_PCDU_MAX_1227_SPEED);
  // Create device handler components
  auto plPcduHandler = new PayloadPcduHandler(
      objects::PLPCDU_HANDLER, objects::SPI_MAIN_COM_IF, spiCookie, gpioComIF,
--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit d72b212fa629029924d9862e3e862d0388911f8e
+Subproject commit e06c457743991b2a0c2d84de9e169508ac428aa8
--- a/linux/ObjectFactory.cpp
+++ b/linux/ObjectFactory.cpp
@ -67,16 +67,15 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
 #if OBSW_ADD_SUN_SENSORS == 1
  SusFdir* fdir = nullptr;
  std::array<SusHandler*, 12> susHandlers = {};
-  SpiCookie* spiCookie =
-      new SpiCookie(addresses::SUS_0, gpioIds::CS_SUS_0, spiDev, SUS::MAX_CMD_SIZE,
-                    spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  SpiCookie* spiCookie = new SpiCookie(addresses::SUS_0, gpioIds::CS_SUS_0, SUS::MAX_CMD_SIZE,
+                                       spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[0] =
      new SusHandler(objects::SUS_0_N_LOC_XFYFZM_PT_XF, 0, objects::SPI_MAIN_COM_IF, spiCookie);
  fdir = new SusFdir(objects::SUS_0_N_LOC_XFYFZM_PT_XF);
  susHandlers[0]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[0]->setCustomFdir(fdir);

-  spiCookie = new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, spiDev, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, SUS::MAX_CMD_SIZE,
                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[1] =
      new SusHandler(objects::SUS_1_N_LOC_XBYFZM_PT_XB, 1, objects::SPI_MAIN_COM_IF, spiCookie);
@ -84,7 +83,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[1]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[1]->setCustomFdir(fdir);

-  spiCookie = new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, spiDev, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, SUS::MAX_CMD_SIZE,
                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[2] =
      new SusHandler(objects::SUS_2_N_LOC_XFYBZB_PT_YB, 2, objects::SPI_MAIN_COM_IF, spiCookie);
@ -92,7 +91,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[2]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[2]->setCustomFdir(fdir);

-  spiCookie = new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, spiDev, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, SUS::MAX_CMD_SIZE,
                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[3] =
      new SusHandler(objects::SUS_3_N_LOC_XFYBZF_PT_YF, 3, objects::SPI_MAIN_COM_IF, spiCookie);
@ -100,7 +99,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[3]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[3]->setCustomFdir(fdir);

-  spiCookie = new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, spiDev, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, SUS::MAX_CMD_SIZE,
                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[4] =
      new SusHandler(objects::SUS_4_N_LOC_XMYFZF_PT_ZF, 4, objects::SPI_MAIN_COM_IF, spiCookie);
@ -108,7 +107,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[4]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[4]->setCustomFdir(fdir);

-  spiCookie = new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, spiDev, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, SUS::MAX_CMD_SIZE,
                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[5] =
      new SusHandler(objects::SUS_5_N_LOC_XFYMZB_PT_ZB, 5, objects::SPI_MAIN_COM_IF, spiCookie);
@ -116,7 +115,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[5]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[5]->setCustomFdir(fdir);

-  spiCookie = new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, spiDev, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, SUS::MAX_CMD_SIZE,
                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[6] =
      new SusHandler(objects::SUS_6_R_LOC_XFYBZM_PT_XF, 6, objects::SPI_MAIN_COM_IF, spiCookie);
@ -124,7 +123,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[6]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[6]->setCustomFdir(fdir);

-  spiCookie = new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, spiDev, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, SUS::MAX_CMD_SIZE,
                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[7] =
      new SusHandler(objects::SUS_7_R_LOC_XBYBZM_PT_XB, 7, objects::SPI_MAIN_COM_IF, spiCookie);
@ -132,7 +131,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[7]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[7]->setCustomFdir(fdir);

-  spiCookie = new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, spiDev, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, SUS::MAX_CMD_SIZE,
                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[8] =
      new SusHandler(objects::SUS_8_R_LOC_XBYBZB_PT_YB, 8, objects::SPI_MAIN_COM_IF, spiCookie);
@ -140,7 +139,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[8]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[8]->setCustomFdir(fdir);

-  spiCookie = new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, spiDev, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, SUS::MAX_CMD_SIZE,
                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[9] =
      new SusHandler(objects::SUS_9_R_LOC_XBYBZB_PT_YF, 9, objects::SPI_MAIN_COM_IF, spiCookie);
@ -148,7 +147,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[9]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[9]->setCustomFdir(fdir);

-  spiCookie = new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, spiDev, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, SUS::MAX_CMD_SIZE,
                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[10] =
      new SusHandler(objects::SUS_10_N_LOC_XMYBZF_PT_ZF, 10, objects::SPI_MAIN_COM_IF, spiCookie);
@ -156,7 +155,7 @@ void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiCo
  susHandlers[10]->setParent(objects::SUS_BOARD_ASS);
  susHandlers[10]->setCustomFdir(fdir);

-  spiCookie = new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, spiDev, SUS::MAX_CMD_SIZE,
+  spiCookie = new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, SUS::MAX_CMD_SIZE,
                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
  susHandlers[11] =
      new SusHandler(objects::SUS_11_R_LOC_XBYMZB_PT_ZB, 11, objects::SPI_MAIN_COM_IF, spiCookie);
@ -286,7 +285,7 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
  RtdFdir* rtdFdir = nullptr;
  for (uint8_t idx = 0; idx < NUMBER_RTDS; idx++) {
    rtdCookies[idx] =
-        new SpiCookie(cookieArgs[idx].first, cookieArgs[idx].second, spiDev,
+        new SpiCookie(cookieArgs[idx].first, cookieArgs[idx].second,
                      Max31865Definitions::MAX_REPLY_SIZE, spi::RTD_MODE, spi::RTD_SPEED);
    rtds[idx] = new Max31865PT1000Handler(rtdIds[idx], objects::SPI_MAIN_COM_IF, rtdCookies[idx]);
    rtds[idx]->setParent(objects::TCS_BOARD_ASS);
--- a/mission/devices/GyroADIS1650XHandler.cpp
+++ b/mission/devices/GyroADIS1650XHandler.cpp
@ -408,7 +408,7 @@ ReturnValue_t GyroADIS1650XHandler::spiSendCallback(SpiComIF *comIf, SpiCookie *
      int retval = 0;
      // Prepare transfer
      int fileDescriptor = 0;
-      std::string device = cookie->getSpiDevice();
+      std::string device = comIf->getSpiDev();
      UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
      if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
        return SpiComIF::OPENING_FILE_FAILED;
--- a/mission/devices/PayloadPcduHandler.cpp
+++ b/mission/devices/PayloadPcduHandler.cpp
@ -697,8 +697,7 @@ ReturnValue_t PayloadPcduHandler::transferAsTwo(SpiComIF* comIf, SpiCookie* cook
  int retval = 0;
  // Prepare transfer
  int fileDescriptor = 0;
-  std::string device = cookie->getSpiDevice();
-  UnixFileGuard fileHelper(device, &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
+  UnixFileGuard fileHelper(comIf->getSpiDev(), &fileDescriptor, O_RDWR, "SpiComIF::sendMessage");
  if (fileHelper.getOpenResult() != HasReturnvaluesIF::RETURN_OK) {
    return SpiComIF::OPENING_FILE_FAILED;
  }