spi setup more stable now

2022-05-14 11:34:25 +02:00 · 2022-05-14 11:34:25 +02:00 · 478975db26
commit 478975db26
parent 1c9f411e75
14 changed files with 97 additions and 45 deletions
--- a/bsp_q7s/boardconfig/busConf.h
+++ b/bsp_q7s/boardconfig/busConf.h
@ -4,6 +4,8 @@
 namespace q7s {

 static constexpr char SPI_DEFAULT_DEV[] = "/dev/spi-main";
+static constexpr uint32_t SPI_MAIN_BUS_LOCK_TIMEOUT = 50;
+
 static constexpr char SPI_RW_DEV[] = "/dev/spi-rw";

 static constexpr char I2C_DEFAULT_DEV[] = "/dev/i2c-eive";
--- a/bsp_q7s/callbacks/rwSpiCallback.cpp
+++ b/bsp_q7s/callbacks/rwSpiCallback.cpp
@ -44,7 +44,8 @@ ReturnValue_t spiCallback(SpiComIF* comIf, SpiCookie* cookie, const uint8_t* sen
  GpioIF* gpioIF = comIf->getGpioInterface();
  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
  uint32_t timeoutMs = 0;
-  MutexIF* mutex = comIf->getMutex(&timeoutType, &timeoutMs);
+  MutexIF* mutex = comIf->getCsMutex();
+  cookie->getMutexParams(timeoutType, timeoutMs);
  if (mutex == nullptr or gpioIF == nullptr) {
    sif::debug << "rwSpiCallback::spiCallback: Mutex or GPIO interface invalid" << std::endl;
    return HasReturnvaluesIF::RETURN_FAILED;
--- a/bsp_q7s/core/InitMission.cpp
+++ b/bsp_q7s/core/InitMission.cpp
@ -146,6 +146,12 @@ void initmission::initTasks() {
  }
 #endif

+  PeriodicTaskIF* tcsPollingTask = factory->createPeriodicTask(
+      "TCS_TASK", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
+  result = tcsPollingTask->addComponent(objects::SPI_RTD_COM_IF);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("SPI_RTD_POLLING", objects::SPI_RTD_COM_IF);
+  }
  PeriodicTaskIF* tcsTask = factory->createPeriodicTask(
      "TCS_TASK", 45, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
  std::array<object_id_t, EiveMax31855::NUM_RTDS> rtdIds = {
@ -273,6 +279,7 @@ void initmission::initTasks() {

  acsTask->startTask();
  sysTask->startTask();
+  tcsPollingTask->startTask();
  tcsTask->startTask();
 #if OBSW_ADD_PLOC_SUPERVISOR == 1
  supvHelperTask->startTask();
--- a/bsp_q7s/core/ObjectFactory.cpp
+++ b/bsp_q7s/core/ObjectFactory.cpp
@ -214,6 +214,7 @@ void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
  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);
+  spiCookieRadSensor->setMutexParams(MutexIF::TimeoutType::WAITING, spi::RAD_SENSOR_CS_TIMEOUT);
  auto radSensor = new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_MAIN_COM_IF,
                                              spiCookieRadSensor, gpioComIF);
  static_cast<void>(radSensor);
--- a/common/config/devConf.h
+++ b/common/config/devConf.h
@ -31,6 +31,7 @@ static constexpr spi::SpiModes DEFAULT_L3G_MODE = spi::SpiModes::MODE_3;
 static const uint32_t SUS_MAX1227_SPI_FREQ = 976'000;
 static constexpr spi::SpiModes SUS_MAX_1227_MODE = spi::SpiModes::MODE_3;

+static constexpr dur_millis_t RAD_SENSOR_CS_TIMEOUT = 250;
 static constexpr uint32_t DEFAULT_MAX_1227_SPEED = 976'000;
 static constexpr spi::SpiModes DEFAULT_MAX_1227_MODE = spi::SpiModes::MODE_3;

@ -42,6 +43,7 @@ static constexpr spi::SpiModes DEFAULT_ADIS16507_MODE = spi::SpiModes::MODE_3;
 static constexpr uint32_t RW_SPEED = 300'000;
 static constexpr spi::SpiModes RW_MODE = spi::SpiModes::MODE_0;

+static constexpr dur_millis_t RTD_CS_TIMEOUT = 40;
 static constexpr uint32_t RTD_SPEED = 2'000'000;
 static constexpr spi::SpiModes RTD_MODE = spi::SpiModes::MODE_3;

--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit dba08fed7a00187ba204f46bc40424f7b87f3aea
+Subproject commit bcd19045cc9f19d9fd0b61f991cb334c6315832a
--- a/linux/ObjectFactory.cpp
+++ b/linux/ObjectFactory.cpp
@ -291,7 +291,7 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
  bool useDirectHandler = false;
  if (not useDirectHandler) {
    // Create special low level reader communication interface
-    new Max31865RtdReader(objects::SPI_RTD_COM_IF, comIF);
+    new Max31865RtdReader(objects::SPI_RTD_COM_IF, comIF, gpioComIF);
  }
  auto directRtdsCreator = [&](uint8_t idx) {
    auto typedHandler =
@ -322,6 +322,7 @@ void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
  for (uint8_t idx = 0; idx < NUM_RTDS; idx++) {
    rtdCookies[idx] = new SpiCookie(cookieArgs[idx].first, cookieArgs[idx].second,
                                    MAX31865::MAX_REPLY_SIZE, spi::RTD_MODE, spi::RTD_SPEED);
+    rtdCookies[idx]->setMutexParams(MutexIF::TimeoutType::WAITING, spi::RTD_CS_TIMEOUT);
    if (useDirectHandler) {
      directRtdsCreator(idx);
    } else {
--- a/linux/devices/Max31865RtdLowlevelHandler.cpp
+++ b/linux/devices/Max31865RtdLowlevelHandler.cpp
@ -1,9 +1,11 @@
 #include "Max31865RtdLowlevelHandler.h"

 #include <fsfw/tasks/TaskFactory.h>
+#include <fsfw/timemanager/Stopwatch.h>
+#include <fsfw_hal/linux/spi/ManualCsLockGuard.h>

-Max31865RtdReader::Max31865RtdReader(object_id_t objectId, SpiComIF* lowLevelComIF)
-    : SystemObject(objectId), rtds(EiveMax31855::NUM_RTDS), comIF(lowLevelComIF) {
+Max31865RtdReader::Max31865RtdReader(object_id_t objectId, SpiComIF* lowLevelComIF, GpioIF* gpioIF)
+    : SystemObject(objectId), rtds(EiveMax31855::NUM_RTDS), comIF(lowLevelComIF), gpioIF(gpioIF) {
  readerMutex = MutexFactory::instance()->createMutex();
 }

@ -18,6 +20,7 @@ ReturnValue_t Max31865RtdReader::performOperation(uint8_t operationCode) {

 void Max31865RtdReader::rtdMainLoop() {
  using namespace MAX31865;
+  // Stopwatch watch;
  if (periodicInitHandling()) {
    // 10 ms delay for VBIAS startup
    TaskFactory::delayTask(10);
@ -55,9 +58,15 @@ bool Max31865RtdReader::periodicInitHandling() {
    }
    if ((rtd->on or rtd->active) and not rtd->configured) {
      if (rtd->cd.hasTimedOut()) {
-        uint8_t cfg = (Bias::OFF << CfgBitPos::BIAS_SEL) |
-                      (Wires::FOUR_WIRE << CfgBitPos::WIRE_SEL) |
-                      (ConvMode::NORM_OFF << CfgBitPos::CONV_MODE);
+        ManualCsLockWrapper mg(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
+        if (mg.lockResult != RETURN_OK or mg.gpioResult != RETURN_OK) {
+          sif::error << "Max31865RtdReader::periodicInitHandling: Manual CS lock failed"
+                     << std::endl;
+          break;
+        }
+        uint8_t cfg =
+            (Bias::OFF << CfgBitPos::BIAS_SEL) | (Wires::FOUR_WIRE << CfgBitPos::WIRE_SEL) |
+            (ConvMode::NORM_OFF << CfgBitPos::CONV_MODE) | (1 << CfgBitPos::FAULT_STATUS_CLEAR);
        result = writeCfgReg(rtd->spiCookie, cfg);
        if (result != HasReturnvaluesIF::RETURN_OK) {
          handleSpiError(rtd, result, "writeCfgReg");
@ -97,6 +106,11 @@ bool Max31865RtdReader::periodicInitHandling() {
      continue;
    }
    if (rtdIsActive(rtd->idx)) {
+      ManualCsLockWrapper mg(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
+      if (mg.lockResult != RETURN_OK or mg.gpioResult != RETURN_OK) {
+        sif::error << "Max31865RtdReader::periodicInitHandling: Manual CS lock failed" << std::endl;
+        break;
+      }
      someRtdUsable = true;
      result = writeBiasSel(Bias::ON, rtd->spiCookie);
    }
@ -117,17 +131,24 @@ void Max31865RtdReader::periodicReadReqHandling() {
      continue;
    }
    if (rtdIsActive(rtd->idx)) {
+      ManualCsLockWrapper mg(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
+      if (mg.lockResult != RETURN_OK or mg.gpioResult != RETURN_OK) {
+        sif::error << "Max31865RtdReader::periodicInitHandling: Manual CS lock failed" << std::endl;
+        break;
+      }
      uint8_t currentCfg = 0;
      auto result = readCfgReg(rtd->spiCookie, currentCfg);
      if (result != RETURN_OK) {
        handleSpiError(rtd, result, "readCfgReg");
-        continue;
+        // Release mutex ASAP
+        break;
      }
      currentCfg |= (1 << CfgBitPos::ONE_SHOT);
      result = writeCfgReg(rtd->spiCookie, currentCfg);
      if (result != RETURN_OK) {
        handleSpiError(rtd, result, "writeCfgReg");
-        continue;
+        // Release mutex ASAP
+        break;
      }
    }
  }
@ -147,6 +168,11 @@ void Max31865RtdReader::periodicReadHandling() {
      continue;
    }
    if (rtdIsActive(rtd->idx)) {
+      ManualCsLockWrapper mg(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
+      if (mg.lockResult != RETURN_OK or mg.gpioResult != RETURN_OK) {
+        sif::error << "Max31865RtdReader::periodicInitHandling: Manual CS lock failed" << std::endl;
+        break;
+      }
      uint16_t rtdVal = 0;
      bool faultBitSet = false;
      result = readRtdVal(rtd->spiCookie, rtdVal, faultBitSet);
@ -167,6 +193,11 @@ void Max31865RtdReader::periodicReadHandling() {
    // Even if a device was made inactive, turn off the bias here. If it was turned off, not
    // necessary anymore..
    if (rtd->on) {
+      ManualCsLockWrapper mg(csLock, gpioIF, rtd->spiCookie, csTimeoutType, csTimeoutMs);
+      if (mg.lockResult != RETURN_OK or mg.gpioResult != RETURN_OK) {
+        sif::error << "Max31865RtdReader::periodicInitHandling: Manual CS lock failed" << std::endl;
+        break;
+      }
      result = writeBiasSel(Bias::OFF, rtd->spiCookie);
    }
  }
@ -338,7 +369,7 @@ ReturnValue_t Max31865RtdReader::clearFaultStatus(SpiCookie* cookie) {
  if (result != RETURN_OK) {
    return result;
  }
-  currentCfg |= (1 << CfgBitPos::FAULTY_STATUS_CLEAR);
+  currentCfg |= (1 << CfgBitPos::FAULT_STATUS_CLEAR);
  return writeCfgReg(cookie, currentCfg);
 }

@ -446,3 +477,8 @@ ReturnValue_t Max31865RtdReader::handleSpiError(Max31865ReaderCookie* cookie, Re
               << std::endl;
  return result;
 }
+
+ReturnValue_t Max31865RtdReader::initialize() {
+  csLock = comIF->getCsMutex();
+  return SystemObject::initialize();
+}
--- a/linux/devices/Max31865RtdLowlevelHandler.h
+++ b/linux/devices/Max31865RtdLowlevelHandler.h
@ -38,9 +38,10 @@ class Max31865RtdReader : public SystemObject,
                          public ExecutableObjectIF,
                          public DeviceCommunicationIF {
 public:
-  Max31865RtdReader(object_id_t objectId, SpiComIF* lowLevelComIF);
+  Max31865RtdReader(object_id_t objectId, SpiComIF* lowLevelComIF, GpioIF* gpioIF);

  [[noreturn]] ReturnValue_t performOperation(uint8_t operationCode) override;
+  ReturnValue_t initialize() override;

 private:
  std::vector<Max31865ReaderCookie*> rtds;
@ -48,6 +49,12 @@ class Max31865RtdReader : public SystemObject,
  size_t dbLen = 0;
  MutexIF* readerMutex;

+  SpiComIF* comIF;
+  GpioIF* gpioIF;
+  MutexIF::TimeoutType csTimeoutType = MutexIF::TimeoutType::BLOCKING;
+  uint32_t csTimeoutMs = 0;
+  MutexIF* csLock = nullptr;
+
  void rtdMainLoop();
  bool periodicInitHandling();
  void periodicReadReqHandling();
@ -75,8 +82,6 @@ class Max31865RtdReader : public SystemObject,
  ReturnValue_t readReceivedMessage(CookieIF* cookie, uint8_t** buffer, size_t* size) override;

  ReturnValue_t handleSpiError(Max31865ReaderCookie* cookie, ReturnValue_t result, const char* ctx);
-
-  SpiComIF* comIF;
 };

 #endif /* LINUX_DEVICES_MAX31865RTDREADER_H_ */
--- a/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp
+++ b/linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp
@ -64,13 +64,12 @@ ReturnValue_t pst::pstSpiRw(FixedTimeslotTaskIF *thisSequence) {
 ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
  uint32_t length = thisSequence->getPeriodMs();
  static_cast<void>(length);
-  thisSequence->addSlot(objects::SPI_RTD_COM_IF, length * 0.0, 0);
 #if OBSW_ADD_PL_PCDU == 1
  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::PLPCDU_HANDLER, length * 0, DeviceHandlerIF::GET_READ);
 #endif
 #if OBSW_ADD_TMP_DEVICES == 1
  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
@ -83,27 +82,18 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
 #endif

 #if OBSW_ADD_TMP_DEVICES == 1
-  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.4, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::GET_WRITE);
 #endif

 #if OBSW_ADD_TMP_DEVICES == 1
-  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.6, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::SEND_READ);
 #endif

 #if OBSW_ADD_TMP_DEVICES == 1
-  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.8, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.8, DeviceHandlerIF::GET_READ);
-#endif
-
-#if OBSW_ADD_RAD_SENSORS == 1
-  /* Radiation sensor */
-  thisSequence->addSlot(objects::RAD_SENSOR, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::RAD_SENSOR, length * 0.2, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::RAD_SENSOR, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::RAD_SENSOR, length * 0.6, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::RAD_SENSOR, length * 0.8, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_1, length * 0.2, DeviceHandlerIF::GET_READ);
+  thisSequence->addSlot(objects::TMP1075_HANDLER_2, length * 0.2, DeviceHandlerIF::GET_READ);
 #endif

 #if OBSW_ADD_SUN_SENSORS == 1
@ -371,6 +361,15 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
  }
 #endif /* OBSW_ADD_SUN_SENSORS == 1 */

+#if OBSW_ADD_RAD_SENSORS == 1
+  /* Radiation sensor */
+  thisSequence->addSlot(objects::RAD_SENSOR, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+  thisSequence->addSlot(objects::RAD_SENSOR, length * 0.2, DeviceHandlerIF::SEND_WRITE);
+  thisSequence->addSlot(objects::RAD_SENSOR, length * 0.4, DeviceHandlerIF::GET_WRITE);
+  thisSequence->addSlot(objects::RAD_SENSOR, length * 0.6, DeviceHandlerIF::SEND_READ);
+  thisSequence->addSlot(objects::RAD_SENSOR, length * 0.8, DeviceHandlerIF::GET_READ);
+#endif
+
 #if OBSW_ADD_ACS_BOARD == 1 && OBSW_ADD_ACS_HANDLERS == 1
  bool enableAside = true;
  bool enableBside = true;
--- a/mission/devices/GyroADIS1650XHandler.cpp
+++ b/mission/devices/GyroADIS1650XHandler.cpp
@ -424,7 +424,8 @@ ReturnValue_t GyroADIS1650XHandler::spiSendCallback(SpiComIF *comIf, SpiCookie *
      GpioIF *gpioIF = comIf->getGpioInterface();
      MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
      uint32_t timeoutMs = 0;
-      MutexIF *mutex = comIf->getMutex(&timeoutType, &timeoutMs);
+      MutexIF *mutex = comIf->getCsMutex();
+      cookie->getMutexParams(timeoutType, timeoutMs);
      if (mutex == nullptr or gpioIF == nullptr) {
 #if OBSW_VERBOSE_LEVEL >= 1
        sif::warning << "GyroADIS16507Handler::spiSendCallback: "
--- a/mission/devices/Max31865EiveHandler.cpp
+++ b/mission/devices/Max31865EiveHandler.cpp
@ -9,6 +9,7 @@ Max31865EiveHandler::Max31865EiveHandler(object_id_t objectId, object_id_t comIF
 }

 void Max31865EiveHandler::doStartUp() {
+  updatePeriodicReply(true, EiveMax31855::RtdCommands::EXCHANGE_SET_ID);
  if (state == InternalState::NONE or state == InternalState::INACTIVE) {
    if (instantNormal) {
      state = InternalState::ACTIVE;
@ -27,6 +28,7 @@ void Max31865EiveHandler::doStartUp() {
 }

 void Max31865EiveHandler::doShutDown() {
+  updatePeriodicReply(false, EiveMax31855::RtdCommands::EXCHANGE_SET_ID);
  if (state == InternalState::NONE or state == InternalState::ACTIVE or
      state == InternalState::ON) {
    state = InternalState::INACTIVE;
@ -107,7 +109,7 @@ void Max31865EiveHandler::fillCommandAndReplyMap() {
  insertInCommandMap(EiveMax31855::RtdCommands::ON);
  insertInCommandMap(EiveMax31855::RtdCommands::ACTIVE);
  insertInCommandMap(EiveMax31855::RtdCommands::OFF);
-  insertInReplyMap(EiveMax31855::RtdCommands::EXCHANGE_SET_ID, 2, &sensorDataset, 0, true);
+  insertInReplyMap(EiveMax31855::RtdCommands::EXCHANGE_SET_ID, 200, &sensorDataset, 0, true);
 }

 ReturnValue_t Max31865EiveHandler::scanForReply(const uint8_t* start, size_t remainingSize,
@ -168,10 +170,4 @@ void Max31865EiveHandler::setDeviceInfo(uint8_t idx_, std::string location_) {
  locString = std::move(location_);
 }

-ReturnValue_t Max31865EiveHandler::initialize() {
-  auto result = DeviceHandlerBase::initialize();
-  if (result != RETURN_OK) {
-    return result;
-  }
-  return updatePeriodicReply(true, EiveMax31855::RtdCommands::EXCHANGE_SET_ID);
-}
+ReturnValue_t Max31865EiveHandler::initialize() { return DeviceHandlerBase::initialize(); }
--- a/mission/devices/PayloadPcduHandler.cpp
+++ b/mission/devices/PayloadPcduHandler.cpp
@ -716,7 +716,7 @@ ReturnValue_t PayloadPcduHandler::transferAsTwo(SpiComIF* comIf, SpiCookie* cook
  GpioIF* gpioIF = comIf->getGpioInterface();
  MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
  uint32_t timeoutMs = 0;
-  MutexIF* mutex = comIf->getMutex(&timeoutType, &timeoutMs);
+  MutexIF* mutex = comIf->getCsMutex();
  if (mutex == nullptr or gpioIF == nullptr) {
 #if OBSW_VERBOSE_LEVEL >= 1
    sif::warning << "GyroADIS16507Handler::spiSendCallback: "
@ -727,6 +727,7 @@ ReturnValue_t PayloadPcduHandler::transferAsTwo(SpiComIF* comIf, SpiCookie* cook
  }

  if (gpioId != gpio::NO_GPIO) {
+    cookie->getMutexParams(timeoutType, timeoutMs);
    result = mutex->lockMutex(timeoutType, timeoutMs);
    if (result != RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
--- a/mission/devices/devicedefinitions/Max31865Definitions.h
+++ b/mission/devices/devicedefinitions/Max31865Definitions.h
@ -20,7 +20,7 @@ enum FilterSel : unsigned int { FIFTY_HERTZ = 1, SIXTY_HERTZ = 0 };

 enum CfgBitPos {
  FILTER_SEL = 0,
-  FAULTY_STATUS_CLEAR = 1,
+  FAULT_STATUS_CLEAR = 1,
  FDCC = 2,
  WIRE_SEL = 4,
  ONE_SHOT = 5,