bsp_linux_board/CMakeLists.txt

@@ -1,6 +1,7 @@
 target_sources(${OBSW_NAME} PUBLIC
 	InitMission.cpp
 	main.cpp
+	gpioInit.cpp
 	ObjectFactory.cpp
 )
 

bsp_linux_board/InitMission.cpp

@@ -192,7 +192,7 @@ void initmission::createPstTasks(TaskFactory& factory,
   ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
 #if OBSW_ADD_SPI_TEST_CODE == 0
   FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
-      "SPI_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 3.0, missedDeadlineFunc);
+      "SPI_PST", 70, PeriodicTaskIF::MINIMUM_STACK_SIZE * 4, 1.0, missedDeadlineFunc);
   result = pst::pstSpi(spiPst);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     sif::error << "InitMission::initTasks: Creating PST failed!" << std::endl;

bsp_linux_board/ObjectFactory.cpp

@@ -5,10 +5,13 @@
 #include "devices/addresses.h"
 #include "devices/gpioIds.h"
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
+#include "fsfw/power/DummyPowerSwitcher.h"
 #include "fsfw/tasks/TaskFactory.h"
 #include "fsfw/tmtcpacket/pus/tm.h"
 #include "fsfw/tmtcservices/CommandingServiceBase.h"
 #include "fsfw/tmtcservices/PusServiceBase.h"
+#include "gpioInit.h"
+#include "linux/ObjectFactory.h"
 #include "linux/boardtest/LibgpiodTest.h"
 #include "linux/boardtest/SpiTestClass.h"
 #include "linux/boardtest/UartTestClass.h"
@@ -64,37 +67,55 @@ void ObjectFactory::produce(void* args) {
   GpioCookie* gpioCookie = nullptr;
   static_cast<void>(gpioCookie);
 
-  new SpiComIF(objects::SPI_COM_IF, gpioIF);
+  SpiComIF* spiComIF = new SpiComIF(objects::SPI_COM_IF, gpioIF);
+  static_cast<void>(spiComIF);
+  auto pwrSwitcher = new DummyPowerSwitcher(objects::PCDU_HANDLER, 18, 0);
+  static_cast<void>(pwrSwitcher);
 
-  std::string spiDev;
+#if OBSW_ADD_ACS_BOARD == 1 && defined(RASPBERRY_PI)
-  SpiCookie* spiCookie = nullptr;
+  createRpiAcsBoard(gpioIF, spiDev);
-  static_cast<void>(spiCookie);
+#endif
 
-#if OBSW_ADD_ACS_BOARD == 1
+#if OBSW_ADD_SUN_SENSORS == 1 || defined(OBSW_ADD_RTD_DEVICES)
-  if (gpioCookie == nullptr) {
+#ifdef RASPBERRY_PI
-    gpioCookie = new GpioCookie();
+  rpi::gpio::initSpiCsDecoder(gpioIF);
-  }
+#endif
+#endif
+
+#if OBSW_ADD_SUN_SENSORS == 1
+  createSunSensorComponents(gpioIF, spiComIF, pwrSwitcher, spi::DEV);
+#endif
+
+#if OBSW_ADD_RTD_DEVICES == 1
+  createRtdComponents(spi::DEV, gpioIF, pwrSwitcher);
+#endif
+
+#if OBSW_ADD_TEST_CODE == 1
+  createTestTasks();
+#endif /* OBSW_ADD_TEST_CODE == 1 */
+}
+
+void ObjectFactory::createRpiAcsBoard(GpioIF* gpioIF, std::string spiDev) {
+  GpioCookie* gpioCookie = new GpioCookie();
   // TODO: Missing pin for Gyro 2
   gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_0_LIS3_CS, gpio::MGM_0_BCM_PIN, "MGM_0_LIS3",
-                            gpio::Direction::OUT, 1);
+                            gpio::Direction::OUT, gpio::Levels::HIGH);
   gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_1_RM3100_CS, gpio::MGM_1_BCM_PIN,
-                            "MGM_1_RM3100", gpio::Direction::OUT, 1);
+                            "MGM_1_RM3100", gpio::Direction::OUT, gpio::Levels::HIGH);
   gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_2_LIS3_CS, gpio::MGM_2_BCM_PIN, "MGM_2_LIS3",
-                            gpio::Direction::OUT, 1);
+                            gpio::Direction::OUT, gpio::Levels::HIGH);
   gpio::createRpiGpioConfig(gpioCookie, gpioIds::MGM_3_RM3100_CS, gpio::MGM_3_BCM_PIN,
-                            "MGM_3_RM3100", gpio::Direction::OUT, 1);
+                            "MGM_3_RM3100", gpio::Direction::OUT, gpio::Levels::HIGH);
   gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_0_ADIS_CS, gpio::GYRO_0_BCM_PIN,
-                            "GYRO_0_ADIS", gpio::Direction::OUT, 1);
+                            "GYRO_0_ADIS", gpio::Direction::OUT, gpio::Levels::HIGH);
   gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_1_L3G_CS, gpio::GYRO_1_BCM_PIN, "GYRO_1_L3G",
-                            gpio::Direction::OUT, 1);
+                            gpio::Direction::OUT, gpio::Levels::HIGH);
   gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_2_ADIS_CS, gpio::GYRO_2_BCM_PIN,
-                            "GYRO_2_ADIS", gpio::Direction::OUT, 1);
+                            "GYRO_2_ADIS", gpio::Direction::OUT, gpio::Levels::HIGH);
   gpio::createRpiGpioConfig(gpioCookie, gpioIds::GYRO_3_L3G_CS, gpio::GYRO_3_BCM_PIN, "GYRO_3_L3G",
-                            gpio::Direction::OUT, 1);
+                            gpio::Direction::OUT, gpio::Levels::HIGH);
   gpioIF->addGpios(gpioCookie);
-
+  SpiCookie* spiCookie =
-  spiDev = "/dev/spidev0.1";
-  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);
   auto mgmLis3Handler =
@@ -136,9 +157,9 @@ void ObjectFactory::produce(void* args) {
 
   spiCookie =
       new SpiCookie(addresses::GYRO_0_ADIS, gpioIds::GYRO_0_ADIS_CS, spiDev,
-                    ADIS16507::MAXIMUM_REPLY_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+                    ADIS1650X::MAXIMUM_REPLY_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
-  auto adisHandler =
+  auto adisHandler = new GyroADIS1650XHandler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF,
-      new GyroADIS16507Handler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF, spiCookie);
+                                              spiCookie, ADIS1650X::Type::ADIS16505);
   adisHandler->setStartUpImmediately();
   spiCookie =
       new SpiCookie(addresses::GYRO_1_L3G, gpioIds::GYRO_1_L3G_CS, spiDev, L3GD20H::MAX_BUFFER_SIZE,
@@ -152,9 +173,9 @@ void ObjectFactory::produce(void* args) {
 
   spiCookie =
       new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, spiDev,
-                    ADIS16507::MAXIMUM_REPLY_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
+                    ADIS1650X::MAXIMUM_REPLY_SIZE, spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
-  adisHandler =
+  adisHandler = new GyroADIS1650XHandler(objects::GYRO_2_ADIS_HANDLER, objects::SPI_COM_IF,
-      new GyroADIS16507Handler(objects::GYRO_2_ADIS_HANDLER, objects::SPI_COM_IF, spiCookie);
+                                         spiCookie, ADIS1650X::Type::ADIS16505);
   adisHandler->setStartUpImmediately();
 
   spiCookie =
@@ -166,12 +187,6 @@ void ObjectFactory::produce(void* args) {
 #if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
   gyroL3gHandler->setToGoToNormalMode(true);
 #endif
-
-#endif /* RPI_TEST_ACS_BOARD == 1 */
-
-#if OBSW_ADD_TEST_CODE == 1
-  createTestTasks();
-#endif /* OBSW_ADD_TEST_CODE == 1 */
 }
 
 void ObjectFactory::createTestTasks() {

bsp_linux_board/ObjectFactory.h

@@ -1,10 +1,15 @@
 #ifndef BSP_LINUX_OBJECTFACTORY_H_
 #define BSP_LINUX_OBJECTFACTORY_H_
 
+#include <string>
+
+class GpioIF;
+
 namespace ObjectFactory {
 void setStatics();
 void produce(void* args);
 
+void createRpiAcsBoard(GpioIF* gpioIF, std::string spiDev);
 void createTestTasks();
 };  // namespace ObjectFactory
 

bsp_linux_board/boardconfig/rpiConfig.h.in

@@ -17,16 +17,4 @@
 
 #define RPI_ADD_UART_TEST               0
 
-/* Adapt these values accordingly */
-namespace gpio {
-static constexpr uint8_t MGM_0_BCM_PIN = 17;
-static constexpr uint8_t MGM_1_BCM_PIN = 27;
-static constexpr uint8_t MGM_2_BCM_PIN = 22;
-static constexpr uint8_t MGM_3_BCM_PIN = 23;
-static constexpr uint8_t GYRO_0_BCM_PIN = 5;
-static constexpr uint8_t GYRO_1_BCM_PIN = 6;
-static constexpr uint8_t GYRO_2_BCM_PIN = 13;
-static constexpr uint8_t GYRO_3_BCM_PIN = 19;
-}
-
 #endif /* BSP_RPI_BOARDCONFIG_RPI_CONFIG_H_ */

bsp_linux_board/definitions.h

@@ -0,0 +1,37 @@
+#ifndef BSP_LINUX_BOARD_DEFINITIONS_H_
+#define BSP_LINUX_BOARD_DEFINITIONS_H_
+
+#include <cstdint>
+
+#include "OBSWConfig.h"
+
+#ifdef RASPBERRY_PI
+
+namespace spi {
+
+static constexpr char DEV[] = "/dev/spidev0.1";
+
+}
+
+/* Adapt these values accordingly */
+namespace gpio {
+static constexpr uint8_t MGM_0_BCM_PIN = 17;
+static constexpr uint8_t MGM_1_BCM_PIN = 27;
+static constexpr uint8_t MGM_2_BCM_PIN = 22;
+static constexpr uint8_t MGM_3_BCM_PIN = 23;
+static constexpr uint8_t GYRO_0_BCM_PIN = 5;
+static constexpr uint8_t GYRO_1_BCM_PIN = 6;
+static constexpr uint8_t GYRO_2_BCM_PIN = 13;
+static constexpr uint8_t GYRO_3_BCM_PIN = 19;
+
+static constexpr uint8_t SPI_MUX_0_BCM = 17;
+static constexpr uint8_t SPI_MUX_1_BCM = 27;
+static constexpr uint8_t SPI_MUX_2_BCM = 22;
+static constexpr uint8_t SPI_MUX_3_BCM = 23;
+static constexpr uint8_t SPI_MUX_4_BCM = 5;
+static constexpr uint8_t SPI_MUX_5_BCM = 6;
+}  // namespace gpio
+
+#endif
+
+#endif /* BSP_LINUX_BOARD_DEFINITIONS_H_ */

bsp_linux_board/gpioInit.cpp

@@ -0,0 +1,56 @@
+#include "gpioInit.h"
+
+#include <devices/gpioIds.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
+#include <fsfw_hal/common/gpio/GpioIF.h>
+
+#include "definitions.h"
+#include "fsfw_hal/linux/rpi/GpioRPi.h"
+
+#ifdef RASPBERRY_PI
+
+struct MuxInfo {
+  MuxInfo(gpioId_t gpioId, int bcmNum, std::string consumer)
+      : gpioId(gpioId), bcmNum(bcmNum), consumer(consumer) {}
+  gpioId_t gpioId;
+  int bcmNum;
+  std::string consumer;
+};
+
+void rpi::gpio::initSpiCsDecoder(GpioIF* gpioComIF) {
+  using namespace ::gpio;
+  ReturnValue_t result;
+
+  if (gpioComIF == nullptr) {
+    sif::debug << "initSpiCsDecoder: Invalid gpioComIF" << std::endl;
+    return;
+  }
+
+  std::array<::MuxInfo, 6> muxInfo{
+      MuxInfo(gpioIds::SPI_MUX_BIT_0, SPI_MUX_0_BCM, "SPI_MUX_0"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_1, SPI_MUX_1_BCM, "SPI_MUX_1"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_2, SPI_MUX_2_BCM, "SPI_MUX_2"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_3, SPI_MUX_3_BCM, "SPI_MUX_3"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_4, SPI_MUX_4_BCM, "SPI_MUX_4"),
+      MuxInfo(gpioIds::SPI_MUX_BIT_5, SPI_MUX_5_BCM, "SPI_MUX_5"),
+  };
+  GpioCookie* spiMuxGpios = new GpioCookie;
+
+  for (const auto& info : muxInfo) {
+    result = createRpiGpioConfig(spiMuxGpios, info.gpioId, info.bcmNum, info.consumer,
+                                 Direction::OUT, Levels::LOW);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      sif::error << "Creating Raspberry Pi SPI Mux GPIO failed with code " << result << std::endl;
+      return;
+    }
+  }
+
+  result = gpioComIF->addGpios(spiMuxGpios);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "initSpiCsDecoder: Failed to add mux bit gpios to gpioComIF" << std::endl;
+    return;
+  }
+}
+
+#endif

bsp_linux_board/gpioInit.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "OBSWConfig.h"
+
+class GpioIF;
+
+#ifdef RASPBERRY_PI
+namespace rpi {
+namespace gpio {
+
+/**
+ * @brief   This function initializes the GPIOs used to control the SN74LVC138APWR decoders on
+ *          the TCS Board and the interface board.
+ */
+void initSpiCsDecoder(GpioIF* gpioComIF);
+
+}  // namespace gpio
+}  // namespace rpi
+
+#endif

bsp_linux_board/main.cpp

@@ -22,7 +22,7 @@ int main(void) {
   std::cout << "-- EIVE OBSW --" << std::endl;
   std::cout << "-- Compiled for Linux board " << BOARD_NAME << " --" << std::endl;
   std::cout << "-- OBSW " << SW_NAME << " v" << SW_VERSION << "." << SW_SUBVERSION << "."
-            << SW_REVISION << ", FSFW v" << fsfw::FSFW_VERSION << "--" << std::endl;
+            << SW_REVISION << ", FSFW v" << fsfw::FSFW_VERSION << " --" << std::endl;
   std::cout << "-- " << __DATE__ << " " << __TIME__ << " --" << std::endl;
 
   initmission::initMission();

bsp_q7s/callbacks/CMakeLists.txt

@@ -2,5 +2,5 @@ target_sources(${OBSW_NAME} PRIVATE
 	rwSpiCallback.cpp
 	gnssCallback.cpp
 	pcduSwitchCb.cpp
-	gpioCallbacks.cpp
+	q7sGpioCallbacks.cpp
 )

bsp_q7s/callbacks/gpioCallbacks.cpp

@@ -1,487 +0,0 @@
-#include "gpioCallbacks.h"
-
-#include <devices/gpioIds.h>
-#include <fsfw/serviceinterface/ServiceInterface.h>
-#include <fsfw_hal/common/gpio/GpioCookie.h>
-#include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
-
-#include "busConf.h"
-
-namespace gpioCallbacks {
-
-GpioIF* gpioComInterface;
-
-void initSpiCsDecoder(GpioIF* gpioComIF) {
-  using namespace gpio;
-  ReturnValue_t result;
-
-  if (gpioComIF == nullptr) {
-    sif::debug << "initSpiCsDecoder: Invalid gpioComIF" << std::endl;
-    return;
-  }
-
-  gpioComInterface = gpioComIF;
-
-  GpioCookie* spiMuxGpios = new GpioCookie;
-
-  GpiodRegularByLineName* spiMuxBit = nullptr;
-  /** Setting mux bit 1 to low will disable IC21 on the interface board */
-  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_0_PIN, "SPI Mux Bit 1",
-                                         Direction::OUT, Levels::HIGH);
-  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_0, spiMuxBit);
-  /** Setting mux bit 2 to low disables IC1 on the TCS board */
-  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_1_PIN, "SPI Mux Bit 2",
-                                         Direction::OUT, Levels::HIGH);
-  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_1, spiMuxBit);
-  /** Setting mux bit 3 to low disables IC2 on the TCS board and IC22 on the interface board */
-  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_2_PIN, "SPI Mux Bit 3",
-                                         Direction::OUT, Levels::LOW);
-  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_2, spiMuxBit);
-
-  /** The following gpios can take arbitrary initial values */
-  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_3_PIN, "SPI Mux Bit 4",
-                                         Direction::OUT, Levels::LOW);
-  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_3, spiMuxBit);
-  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_4_PIN, "SPI Mux Bit 5",
-                                         Direction::OUT, Levels::LOW);
-  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_4, spiMuxBit);
-  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_5_PIN, "SPI Mux Bit 6",
-                                         Direction::OUT, Levels::LOW);
-  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_5, spiMuxBit);
-  GpiodRegularByLineName* enRwDecoder = new GpiodRegularByLineName(
-      q7s::gpioNames::EN_RW_CS, "EN_RW_CS", Direction::OUT, Levels::HIGH);
-  spiMuxGpios->addGpio(gpioIds::EN_RW_CS, enRwDecoder);
-
-  result = gpioComInterface->addGpios(spiMuxGpios);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "initSpiCsDecoder: Failed to add mux bit gpios to gpioComIF" << std::endl;
-    return;
-  }
-}
-
-void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Levels value,
-                          void* args) {
-  using namespace gpio;
-  if (gpioComInterface == nullptr) {
-    sif::debug << "spiCsDecoderCallback: No gpioComIF specified. Call initSpiCsDecoder "
-               << "to specify gpioComIF" << std::endl;
-    return;
-  }
-
-  /* Reading is not supported by the callback function */
-  if (gpioOp == gpio::GpioOperation::READ) {
-    return;
-  }
-
-  if (value == Levels::HIGH) {
-    switch (gpioId) {
-      case (gpioIds::RTD_IC_3): {
-        disableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_4): {
-        disableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_5): {
-        disableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_6): {
-        disableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_7): {
-        disableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_8): {
-        disableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_9): {
-        disableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_10): {
-        disableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_11): {
-        disableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_12): {
-        disableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_13): {
-        disableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_14): {
-        disableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_15): {
-        disableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_16): {
-        disableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_17): {
-        disableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_18): {
-        disableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_0): {
-        disableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_1): {
-        disableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_2): {
-        disableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_3): {
-        disableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_4): {
-        disableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_5): {
-        disableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_6): {
-        disableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_7): {
-        disableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_8): {
-        disableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_9): {
-        disableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_10): {
-        disableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_11): {
-        disableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_RW1): {
-        disableRwDecoder();
-        break;
-      }
-      case (gpioIds::CS_RW2): {
-        disableRwDecoder();
-        break;
-      }
-      case (gpioIds::CS_RW3): {
-        disableRwDecoder();
-        break;
-      }
-      case (gpioIds::CS_RW4): {
-        disableRwDecoder();
-        break;
-      }
-      default:
-        sif::debug << "spiCsDecoderCallback: Invalid gpio id " << gpioId << std::endl;
-    }
-  } else if (value == Levels::LOW) {
-    switch (gpioId) {
-      case (gpioIds::RTD_IC_3): {
-        selectY7();
-        enableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_4): {
-        selectY6();
-        enableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_5): {
-        selectY5();
-        enableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_6): {
-        selectY4();
-        enableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_7): {
-        selectY3();
-        enableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_8): {
-        selectY2();
-        enableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_9): {
-        selectY1();
-        enableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_10): {
-        selectY0();
-        enableDecoderTcsIc1();
-        break;
-      }
-      case (gpioIds::RTD_IC_11): {
-        selectY7();
-        enableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_12): {
-        selectY6();
-        enableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_13): {
-        selectY5();
-        enableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_14): {
-        selectY4();
-        enableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_15): {
-        selectY3();
-        enableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_16): {
-        selectY2();
-        enableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_17): {
-        selectY1();
-        enableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::RTD_IC_18): {
-        selectY0();
-        enableDecoderTcsIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_0): {
-        selectY0();
-        enableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_1): {
-        selectY1();
-        enableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_2): {
-        selectY2();
-        enableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_3): {
-        selectY3();
-        enableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_4): {
-        selectY4();
-        enableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_5): {
-        selectY5();
-        enableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_6): {
-        selectY0();
-        enableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_7): {
-        selectY1();
-        enableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_8): {
-        selectY2();
-        enableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_9): {
-        selectY3();
-        enableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_10): {
-        selectY4();
-        enableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_11): {
-        selectY5();
-        enableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_RW1): {
-        selectY0();
-        enableRwDecoder();
-        break;
-      }
-      case (gpioIds::CS_RW2): {
-        selectY1();
-        enableRwDecoder();
-        break;
-      }
-      case (gpioIds::CS_RW3): {
-        selectY2();
-        enableRwDecoder();
-        break;
-      }
-      case (gpioIds::CS_RW4): {
-        selectY3();
-        enableRwDecoder();
-        break;
-      }
-      default:
-        sif::debug << "spiCsDecoderCallback: Invalid gpio id " << gpioId << std::endl;
-    }
-  } else {
-    sif::debug << "spiCsDecoderCallback: Invalid value. Must be 0 or 1" << std::endl;
-  }
-}
-
-void enableDecoderTcsIc1() {
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_0);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-}
-
-void enableDecoderTcsIc2() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_0);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-}
-
-void enableDecoderInterfaceBoardIc1() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-}
-
-void enableDecoderInterfaceBoardIc2() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
-}
-
-void disableDecoderTcsIc1() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-}
-
-void disableDecoderTcsIc2() {
-  // DO NOT CHANGE THE ORDER HERE
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-}
-
-void disableDecoderInterfaceBoardIc1() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-}
-
-void disableDecoderInterfaceBoardIc2() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-}
-
-void enableRwDecoder() { gpioComInterface->pullHigh(gpioIds::EN_RW_CS); }
-
-void disableRwDecoder() { gpioComInterface->pullLow(gpioIds::EN_RW_CS); }
-
-void selectY0() {
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
-}
-
-void selectY1() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
-}
-
-void selectY2() {
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
-}
-
-void selectY3() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
-}
-
-void selectY4() {
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
-}
-
-void selectY5() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
-}
-
-void selectY6() {
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
-}
-
-void selectY7() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
-}
-
-void disableAllDecoder() {
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_0);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
-  gpioComInterface->pullLow(gpioIds::EN_RW_CS);
-}
-
-}  // namespace gpioCallbacks

bsp_q7s/callbacks/q7sGpioCallbacks.cpp

@@ -0,0 +1,54 @@
+#include "q7sGpioCallbacks.h"
+
+#include <devices/gpioIds.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
+#include <fsfw_hal/common/gpio/GpioIF.h>
+
+#include "busConf.h"
+
+void q7s::gpioCallbacks::initSpiCsDecoder(GpioIF* gpioComIF) {
+  using namespace gpio;
+  ReturnValue_t result;
+
+  if (gpioComIF == nullptr) {
+    sif::debug << "initSpiCsDecoder: Invalid gpioComIF" << std::endl;
+    return;
+  }
+
+  GpioCookie* spiMuxGpios = new GpioCookie;
+
+  GpiodRegularByLineName* spiMuxBit = nullptr;
+  /** Setting mux bit 1 to low will disable IC21 on the interface board */
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_0_PIN, "SPI Mux Bit 1",
+                                         Direction::OUT, Levels::HIGH);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_0, spiMuxBit);
+  /** Setting mux bit 2 to low disables IC1 on the TCS board */
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_1_PIN, "SPI Mux Bit 2",
+                                         Direction::OUT, Levels::HIGH);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_1, spiMuxBit);
+  /** Setting mux bit 3 to low disables IC2 on the TCS board and IC22 on the interface board */
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_2_PIN, "SPI Mux Bit 3",
+                                         Direction::OUT, Levels::LOW);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_2, spiMuxBit);
+
+  /** The following gpios can take arbitrary initial values */
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_3_PIN, "SPI Mux Bit 4",
+                                         Direction::OUT, Levels::LOW);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_3, spiMuxBit);
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_4_PIN, "SPI Mux Bit 5",
+                                         Direction::OUT, Levels::LOW);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_4, spiMuxBit);
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_5_PIN, "SPI Mux Bit 6",
+                                         Direction::OUT, Levels::LOW);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_5, spiMuxBit);
+  GpiodRegularByLineName* enRwDecoder = new GpiodRegularByLineName(
+      q7s::gpioNames::EN_RW_CS, "EN_RW_CS", Direction::OUT, Levels::HIGH);
+  spiMuxGpios->addGpio(gpioIds::EN_RW_CS, enRwDecoder);
+
+  result = gpioComIF->addGpios(spiMuxGpios);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::error << "initSpiCsDecoder: Failed to add mux bit gpios to gpioComIF" << std::endl;
+    return;
+  }
+}

bsp_q7s/callbacks/q7sGpioCallbacks.h

@@ -0,0 +1,15 @@
+#pragma once
+
+class GpioIF;
+
+namespace q7s {
+namespace gpioCallbacks {
+
+/**
+ * @brief   This function initializes the GPIOs used to control the SN74LVC138APWR decoders on
+ *          the TCS Board and the interface board.
+ */
+void initSpiCsDecoder(GpioIF* gpioComIF);
+
+}  // namespace gpioCallbacks
+}  // namespace q7s

bsp_q7s/core/ObjectFactory.cpp

@@ -1,22 +1,10 @@
 #include "ObjectFactory.h"
 
-#include <fsfw/ipc/QueueFactory.h>
-#include <linux/obc/AxiPtmeConfig.h>
-#include <linux/obc/PapbVcInterface.h>
-#include <linux/obc/PdecHandler.h>
-#include <linux/obc/Ptme.h>
-#include <linux/obc/PtmeConfig.h>
-#include <mission/system/AcsBoardFdir.h>
-#include <mission/system/RtdFdir.h>
-#include <mission/system/SusAssembly.h>
-#include <mission/system/SusFdir.h>
-#include <mission/system/TcsBoardAssembly.h>
-
 #include "OBSWConfig.h"
 #include "bsp_q7s/boardtest/Q7STestTask.h"
 #include "bsp_q7s/callbacks/gnssCallback.h"
-#include "bsp_q7s/callbacks/gpioCallbacks.h"
 #include "bsp_q7s/callbacks/pcduSwitchCb.h"
+#include "bsp_q7s/callbacks/q7sGpioCallbacks.h"
 #include "bsp_q7s/callbacks/rwSpiCallback.h"
 #include "bsp_q7s/core/CoreController.h"
 #include "bsp_q7s/memory/FileSystemHandler.h"
@@ -26,9 +14,12 @@
 #include "devices/addresses.h"
 #include "devices/gpioIds.h"
 #include "devices/powerSwitcherList.h"
+#include "fsfw/ipc/QueueFactory.h"
+#include "linux/ObjectFactory.h"
 #include "linux/boardtest/I2cTestClass.h"
 #include "linux/boardtest/SpiTestClass.h"
 #include "linux/boardtest/UartTestClass.h"
+#include "linux/callbacks/gpioCallbacks.h"
 #include "linux/csp/CspComIF.h"
 #include "linux/csp/CspCookie.h"
 #include "linux/devices/GPSHyperionLinuxController.h"
@@ -41,6 +32,16 @@
 #include "linux/devices/ploc/PlocUpdater.h"
 #include "linux/devices/startracker/StarTrackerHandler.h"
 #include "linux/devices/startracker/StrHelper.h"
+#include "linux/obc/AxiPtmeConfig.h"
+#include "linux/obc/PapbVcInterface.h"
+#include "linux/obc/PdecHandler.h"
+#include "linux/obc/Ptme.h"
+#include "linux/obc/PtmeConfig.h"
+#include "mission/system/AcsBoardFdir.h"
+#include "mission/system/RtdFdir.h"
+#include "mission/system/SusAssembly.h"
+#include "mission/system/SusFdir.h"
+#include "mission/system/TcsBoardAssembly.h"
 #include "tmtc/apid.h"
 #include "tmtc/pusIds.h"
 
@@ -138,10 +139,10 @@ void ObjectFactory::produce(void* args) {
   createTmpComponents();
   new CoreController(objects::CORE_CONTROLLER);
 
-  gpioCallbacks::disableAllDecoder();
+  gpioCallbacks::disableAllDecoder(gpioComIF);
   createPcduComponents(gpioComIF, &pwrSwitcher);
   createRadSensorComponent(gpioComIF);
-  createSunSensorComponents(gpioComIF, spiComIF, pwrSwitcher);
+  createSunSensorComponents(gpioComIF, spiComIF, pwrSwitcher, q7s::SPI_DEFAULT_DEV);
 
 #if OBSW_ADD_ACS_BOARD == 1
   createAcsBoardComponents(gpioComIF, uartComIF, pwrSwitcher);
@@ -149,11 +150,11 @@ void ObjectFactory::produce(void* args) {
 
   createHeaterComponents();
   createSolarArrayDeploymentComponents();
-  createPlPcduComponents(gpioComIF, spiComIF);
+  createPlPcduComponents(gpioComIF, spiComIF, pwrSwitcher);
 #if OBSW_ADD_SYRLINKS == 1
   createSyrlinksComponents();
 #endif /* OBSW_ADD_SYRLINKS == 1 */
-  createRtdComponents(gpioComIF, pwrSwitcher);
+  createRtdComponents(q7s::SPI_DEFAULT_DEV, gpioComIF, pwrSwitcher);
   createPayloadComponents(gpioComIF);
 
 #if OBSW_ADD_MGT == 1
@@ -239,7 +240,7 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, Ua
   *spiComIF = new SpiComIF(objects::SPI_COM_IF, *gpioComIF);
 
   /* Adding gpios for chip select decoding to the gpioComIf */
-  gpioCallbacks::initSpiCsDecoder(*gpioComIF);
+  q7s::gpioCallbacks::initSpiCsDecoder(*gpioComIF);
 }
 
 void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher) {
@@ -298,161 +299,6 @@ void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
 #endif
 }
 
-void ObjectFactory::createSunSensorComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
-                                              PowerSwitchIF* pwrSwitcher) {
-  using namespace gpio;
-  GpioCookie* gpioCookieSus = new GpioCookie();
-  GpioCallback* susgpio = nullptr;
-
-  susgpio = new GpioCallback("Chip select SUS 0", Direction::OUT, Levels::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_0, susgpio);
-  susgpio = new GpioCallback("Chip select SUS 1", Direction::OUT, Levels::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_1, susgpio);
-  susgpio = new GpioCallback("Chip select SUS 2", Direction::OUT, Levels::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_2, susgpio);
-  susgpio = new GpioCallback("Chip select SUS 3", Direction::OUT, Levels::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_3, susgpio);
-  susgpio = new GpioCallback("Chip select SUS 4", Direction::OUT, Levels::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_4, susgpio);
-  susgpio = new GpioCallback("Chip select SUS 5", Direction::OUT, Levels::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_5, susgpio);
-  susgpio = new GpioCallback("Chip select SUS 6", Direction::OUT, Levels::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_6, susgpio);
-  susgpio = new GpioCallback("Chip select SUS 7", Direction::OUT, Levels::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_7, susgpio);
-  susgpio = new GpioCallback("Chip select SUS 8", Direction::OUT, Levels::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_8, susgpio);
-  susgpio = new GpioCallback("Chip select SUS 9", Direction::OUT, Levels::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_9, susgpio);
-  susgpio = new GpioCallback("Chip select SUS 10", Direction::OUT, Levels::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_10, susgpio);
-  susgpio = new GpioCallback("Chip select SUS 11", Direction::OUT, Levels::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_11, susgpio);
-
-  gpioComIF->addGpios(gpioCookieSus);
-
-  SusFdir* fdir = nullptr;
-  std::array<SusHandler*, 12> susHandlers = {};
-#if OBSW_ADD_SUN_SENSORS == 1
-  SpiCookie* spiCookie =
-      new SpiCookie(addresses::SUS_0, gpioIds::CS_SUS_0, q7s::SPI_DEFAULT_DEV, SUS::MAX_CMD_SIZE,
-                    spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  susHandlers[0] = new SusHandler(objects::SUS_0, 0, objects::SPI_COM_IF, spiCookie);
-  fdir = new SusFdir(objects::SUS_0);
-  susHandlers[0]->setParent(objects::SUS_BOARD_ASS);
-  susHandlers[0]->setCustomFdir(fdir);
-
-  spiCookie = new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, q7s::SPI_DEFAULT_DEV,
-                            SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  susHandlers[1] = new SusHandler(objects::SUS_1, 1, objects::SPI_COM_IF, spiCookie);
-  fdir = new SusFdir(objects::SUS_1);
-  susHandlers[1]->setParent(objects::SUS_BOARD_ASS);
-  susHandlers[1]->setCustomFdir(fdir);
-
-  spiCookie = new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, q7s::SPI_DEFAULT_DEV,
-                            SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  susHandlers[2] = new SusHandler(objects::SUS_2, 2, objects::SPI_COM_IF, spiCookie);
-  fdir = new SusFdir(objects::SUS_2);
-  susHandlers[2]->setParent(objects::SUS_BOARD_ASS);
-  susHandlers[2]->setCustomFdir(fdir);
-
-  spiCookie = new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, std::string(q7s::SPI_DEFAULT_DEV),
-                            SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  susHandlers[3] = new SusHandler(objects::SUS_3, 3, objects::SPI_COM_IF, spiCookie);
-  fdir = new SusFdir(objects::SUS_3);
-  susHandlers[3]->setParent(objects::SUS_BOARD_ASS);
-  susHandlers[3]->setCustomFdir(fdir);
-
-  spiCookie = new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, std::string(q7s::SPI_DEFAULT_DEV),
-                            SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  susHandlers[4] = new SusHandler(objects::SUS_4, 4, objects::SPI_COM_IF, spiCookie);
-  fdir = new SusFdir(objects::SUS_4);
-  susHandlers[4]->setParent(objects::SUS_BOARD_ASS);
-  susHandlers[4]->setCustomFdir(fdir);
-
-  spiCookie = new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, std::string(q7s::SPI_DEFAULT_DEV),
-                            SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  susHandlers[5] = new SusHandler(objects::SUS_5, 5, objects::SPI_COM_IF, spiCookie);
-  fdir = new SusFdir(objects::SUS_5);
-  susHandlers[5]->setParent(objects::SUS_BOARD_ASS);
-  susHandlers[5]->setCustomFdir(fdir);
-
-  spiCookie = new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, q7s::SPI_DEFAULT_DEV,
-                            SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  susHandlers[6] = new SusHandler(objects::SUS_6, 6, objects::SPI_COM_IF, spiCookie);
-  fdir = new SusFdir(objects::SUS_6);
-  susHandlers[6]->setParent(objects::SUS_BOARD_ASS);
-  susHandlers[6]->setCustomFdir(fdir);
-
-  spiCookie = new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, q7s::SPI_DEFAULT_DEV,
-                            SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  susHandlers[7] = new SusHandler(objects::SUS_7, 7, objects::SPI_COM_IF, spiCookie);
-  fdir = new SusFdir(objects::SUS_7);
-  susHandlers[7]->setParent(objects::SUS_BOARD_ASS);
-  susHandlers[7]->setCustomFdir(fdir);
-
-  spiCookie = new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, q7s::SPI_DEFAULT_DEV,
-                            SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  susHandlers[8] = new SusHandler(objects::SUS_8, 8, objects::SPI_COM_IF, spiCookie);
-  fdir = new SusFdir(objects::SUS_8);
-  susHandlers[8]->setParent(objects::SUS_BOARD_ASS);
-  susHandlers[8]->setCustomFdir(fdir);
-
-  spiCookie = new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, q7s::SPI_DEFAULT_DEV,
-                            SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  susHandlers[9] = new SusHandler(objects::SUS_9, 9, objects::SPI_COM_IF, spiCookie);
-  fdir = new SusFdir(objects::SUS_9);
-  susHandlers[9]->setParent(objects::SUS_BOARD_ASS);
-  susHandlers[9]->setCustomFdir(fdir);
-
-  spiCookie = new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, q7s::SPI_DEFAULT_DEV,
-                            SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  susHandlers[10] = new SusHandler(objects::SUS_10, 10, objects::SPI_COM_IF, spiCookie);
-  fdir = new SusFdir(objects::SUS_10);
-  susHandlers[10]->setParent(objects::SUS_BOARD_ASS);
-  susHandlers[10]->setCustomFdir(fdir);
-
-  spiCookie = new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, q7s::SPI_DEFAULT_DEV,
-                            SUS::MAX_CMD_SIZE, spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  susHandlers[11] = new SusHandler(objects::SUS_11, 11, objects::SPI_COM_IF, spiCookie);
-  fdir = new SusFdir(objects::SUS_11);
-  susHandlers[11]->setParent(objects::SUS_BOARD_ASS);
-  susHandlers[11]->setCustomFdir(fdir);
-
-  for (auto& sus : susHandlers) {
-    if (sus != nullptr) {
-#if OBSW_TEST_SUS == 1
-      sus->setStartUpImmediately();
-      sus->setToGoToNormalMode(true);
-#endif
-#if OBSW_DEBUG_SUS == 1
-      sus->enablePeriodicPrintout(true, 3);
-#endif
-    }
-  }
-  std::array<object_id_t, 12> susIds = {objects::SUS_0, objects::SUS_1,  objects::SUS_2,
-                                        objects::SUS_3, objects::SUS_4,  objects::SUS_5,
-                                        objects::SUS_6, objects::SUS_7,  objects::SUS_8,
-                                        objects::SUS_9, objects::SUS_10, objects::SUS_11};
-  SusAssHelper susAssHelper = SusAssHelper(susIds);
-  auto susAss =
-      new SusAssembly(objects::SUS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher, susAssHelper);
-  static_cast<void>(susAss);
-#endif /* OBSW_ADD_SUN_SENSORS == 1 */
-}
-
 void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF,
                                              PowerSwitchIF* pwrSwitcher) {
   using namespace gpio;
@@ -789,116 +635,6 @@ void ObjectFactory::createSyrlinksComponents() {
   new SyrlinksHkHandler(objects::SYRLINKS_HK_HANDLER, objects::UART_COM_IF, syrlinksUartCookie);
 }
 
-void ObjectFactory::createRtdComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher) {
-  using namespace gpio;
-  GpioCookie* rtdGpioCookie = new GpioCookie;
-
-  GpioCallback* gpioRtdIc0 = new GpioCallback("Chip select RTD IC0", Direction::OUT, Levels::HIGH,
-                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_3, gpioRtdIc0);
-  GpioCallback* gpioRtdIc1 = new GpioCallback("Chip select RTD IC1", Direction::OUT, Levels::HIGH,
-                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_4, gpioRtdIc1);
-  GpioCallback* gpioRtdIc2 = new GpioCallback("Chip select RTD IC2", Direction::OUT, Levels::HIGH,
-                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_5, gpioRtdIc2);
-  GpioCallback* gpioRtdIc3 = new GpioCallback("Chip select RTD IC3", Direction::OUT, Levels::HIGH,
-                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_6, gpioRtdIc3);
-  GpioCallback* gpioRtdIc4 = new GpioCallback("Chip select RTD IC4", Direction::OUT, Levels::HIGH,
-                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_7, gpioRtdIc4);
-  GpioCallback* gpioRtdIc5 = new GpioCallback("Chip select RTD IC5", Direction::OUT, Levels::HIGH,
-                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_8, gpioRtdIc5);
-  GpioCallback* gpioRtdIc6 = new GpioCallback("Chip select RTD IC6", Direction::OUT, Levels::HIGH,
-                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_9, gpioRtdIc6);
-  GpioCallback* gpioRtdIc7 = new GpioCallback("Chip select RTD IC7", Direction::OUT, Levels::HIGH,
-                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_10, gpioRtdIc7);
-  GpioCallback* gpioRtdIc8 = new GpioCallback("Chip select RTD IC8", Direction::OUT, Levels::HIGH,
-                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_11, gpioRtdIc8);
-  GpioCallback* gpioRtdIc9 = new GpioCallback("Chip select RTD IC9", Direction::OUT, Levels::HIGH,
-                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_12, gpioRtdIc9);
-  GpioCallback* gpioRtdIc10 = new GpioCallback("Chip select RTD IC10", Direction::OUT, Levels::HIGH,
-                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_13, gpioRtdIc10);
-  GpioCallback* gpioRtdIc11 = new GpioCallback("Chip select RTD IC11", Direction::OUT, Levels::HIGH,
-                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_14, gpioRtdIc11);
-  GpioCallback* gpioRtdIc12 = new GpioCallback("Chip select RTD IC12", Direction::OUT, Levels::HIGH,
-                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_15, gpioRtdIc12);
-  GpioCallback* gpioRtdIc13 = new GpioCallback("Chip select RTD IC13", Direction::OUT, Levels::HIGH,
-                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_16, gpioRtdIc13);
-  GpioCallback* gpioRtdIc14 = new GpioCallback("Chip select RTD IC14", Direction::OUT, Levels::HIGH,
-                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_17, gpioRtdIc14);
-  GpioCallback* gpioRtdIc15 = new GpioCallback("Chip select RTD IC15", Direction::OUT, Levels::HIGH,
-                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  rtdGpioCookie->addGpio(gpioIds::RTD_IC_18, gpioRtdIc15);
-
-  gpioComIF->addGpios(rtdGpioCookie);
-
-  static constexpr uint8_t NUMBER_RTDS = 16;
-#if OBSW_ADD_RTD_DEVICES == 1
-  std::array<std::pair<address_t, gpioId_t>, NUMBER_RTDS> cookieArgs = {{
-      {addresses::RTD_IC_3, gpioIds::RTD_IC_3},
-      {addresses::RTD_IC_4, gpioIds::RTD_IC_4},
-      {addresses::RTD_IC_5, gpioIds::RTD_IC_5},
-      {addresses::RTD_IC_6, gpioIds::RTD_IC_6},
-      {addresses::RTD_IC_7, gpioIds::RTD_IC_7},
-      {addresses::RTD_IC_8, gpioIds::RTD_IC_8},
-      {addresses::RTD_IC_9, gpioIds::RTD_IC_9},
-      {addresses::RTD_IC_10, gpioIds::RTD_IC_10},
-      {addresses::RTD_IC_11, gpioIds::RTD_IC_11},
-      {addresses::RTD_IC_12, gpioIds::RTD_IC_12},
-      {addresses::RTD_IC_13, gpioIds::RTD_IC_13},
-      {addresses::RTD_IC_14, gpioIds::RTD_IC_14},
-      {addresses::RTD_IC_15, gpioIds::RTD_IC_15},
-      {addresses::RTD_IC_16, gpioIds::RTD_IC_16},
-      {addresses::RTD_IC_17, gpioIds::RTD_IC_17},
-      {addresses::RTD_IC_18, gpioIds::RTD_IC_18},
-  }};
-  std::array<object_id_t, NUMBER_RTDS> rtdIds = {
-      objects::RTD_IC_3,  objects::RTD_IC_4,  objects::RTD_IC_5,  objects::RTD_IC_6,
-      objects::RTD_IC_7,  objects::RTD_IC_8,  objects::RTD_IC_9,  objects::RTD_IC_10,
-      objects::RTD_IC_11, objects::RTD_IC_12, objects::RTD_IC_13, objects::RTD_IC_14,
-      objects::RTD_IC_15, objects::RTD_IC_16, objects::RTD_IC_17, objects::RTD_IC_18};
-  std::array<SpiCookie*, NUMBER_RTDS> rtdCookies = {};
-  std::array<Max31865PT1000Handler*, NUMBER_RTDS> rtds = {};
-  RtdFdir* rtdFdir = nullptr;
-  for (uint8_t idx = 0; idx < NUMBER_RTDS; idx++) {
-    rtdCookies[idx] =
-        new SpiCookie(cookieArgs[idx].first, cookieArgs[idx].second, q7s::SPI_DEFAULT_DEV,
-                      Max31865Definitions::MAX_REPLY_SIZE, spi::RTD_MODE, spi::RTD_SPEED);
-    rtds[idx] = new Max31865PT1000Handler(rtdIds[idx], objects::SPI_COM_IF, rtdCookies[idx]);
-    rtds[idx]->setParent(objects::TCS_BOARD_ASS);
-    rtdFdir = new RtdFdir(rtdIds[idx]);
-    rtds[idx]->setCustomFdir(rtdFdir);
-    rtds[idx]->setDeviceIdx(idx + 3);
-  }
-
-#if OBSW_TEST_RTD == 1
-  for (auto& rtd : rtds) {
-    if (rtd != nullptr) {
-      rtd->setStartUpImmediately();
-      rtd->setInstantNormal(true);
-    }
-  }
-#endif  // OBSW_TEST_RTD == 1
-  TcsBoardHelper helper(rtdIds);
-  TcsBoardAssembly* tcsBoardAss =
-      new TcsBoardAssembly(objects::TCS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher,
-                           pcduSwitches::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
-  static_cast<void>(tcsBoardAss);
-#endif  // OBSW_ADD_RTD_DEVICES == 1
-}
-
 void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF) {
   using namespace gpio;
   std::stringstream consumer;
@@ -1140,7 +876,8 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
   gpioComIF->addGpios(gpioRS485Chip);
 }
 
-void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF) {
+void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
+                                           PowerSwitchIF* pwrSwitcher) {
   using namespace gpio;
   // Create all GPIO components first
   GpioCookie* plPcduGpios = new GpioCookie;
@@ -1186,9 +923,10 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF*
                                        q7s::SPI_DEFAULT_DEV, plpcdu::MAX_ADC_REPLY_SIZE,
                                        spi::DEFAULT_MAX_1227_MODE, spi::PL_PCDU_MAX_1227_SPEED);
   // Create device handler components
-  auto plPcduHandler =
+  auto plPcduHandler = new PayloadPcduHandler(
-      new PayloadPcduHandler(objects::PLPCDU_HANDLER, objects::SPI_COM_IF, spiCookie, gpioComIF,
+      objects::PLPCDU_HANDLER, objects::SPI_COM_IF, spiCookie, gpioComIF, SdCardManager::instance(),
-                             SdCardManager::instance(), false);
+      pwrSwitcher, pcduSwitches::Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8,
+      pcduSwitches::Switches::PDU2_CH6_PL_PCDU_BATT_1_14V8, false);
   spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler);
 //  plPcduHandler->enablePeriodicPrintout(true, 5);
 //  static_cast<void>(plPcduHandler);

bsp_q7s/core/ObjectFactory.h

@@ -16,17 +16,15 @@ void produce(void* args);
 void createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, UartComIF** uartComIF,
                                    SpiComIF** spiComIF, I2cComIF** i2cComIF);
 void createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher);
-void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF);
+void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
+                            PowerSwitchIF* pwrSwitcher);
 void createTmpComponents();
 void createRadSensorComponent(LinuxLibgpioIF* gpioComIF);
-void createSunSensorComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
-                               PowerSwitchIF* pwrSwitcher);
 void createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF,
                               PowerSwitchIF* pwrSwitcher);
 void createHeaterComponents();
 void createSolarArrayDeploymentComponents();
 void createSyrlinksComponents();
-void createRtdComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher);
 void createPayloadComponents(LinuxLibgpioIF* gpioComIF);
 void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF);
 void createCcsdsComponents(LinuxLibgpioIF* gpioComIF);

common/config/devices/powerSwitcherList.h

@@ -3,12 +3,15 @@
 
 #include "OBSWConfig.h"
 
+#include <fsfw/power/definitions.h>
+
 #include <array>
 #include <cstdint>
 
 namespace pcduSwitches {
+
 /* Switches are uint8_t datatype and go from 0 to 255 */
-enum Switches: uint8_t {
+enum Switches: power::Switch_t {
   PDU1_CH0_TCS_BOARD_3V3,
   PDU1_CH1_SYRLINKS_12V,
   PDU1_CH2_STAR_TRACKER_5V,

generators/fsfwgen

@@ -1 +1 @@
-Subproject commit a3ea5dd2e7223c52e4f494e170850609b7b3a572
+Subproject commit 5ad9fb94af3312d29863527106396395f7b808a5

linux/CMakeLists.txt

@@ -1,6 +1,11 @@
 add_subdirectory(csp)
 add_subdirectory(utility)
+add_subdirectory(callbacks)
 add_subdirectory(boardtest)
 add_subdirectory(devices)
 add_subdirectory(fsfwconfig)
 add_subdirectory(obc)
+
+target_sources(${OBSW_NAME} PUBLIC
+    ObjectFactory.cpp
+)

linux/ObjectFactory.cpp

@@ -0,0 +1,286 @@
+#include "ObjectFactory.h"
+
+#include <fsfw/power/PowerSwitchIF.h>
+#include <fsfw_hal/common/gpio/GpioCookie.h>
+#include <fsfw_hal/common/gpio/GpioIF.h>
+#include <fsfw_hal/common/gpio/gpioDefinitions.h>
+#include <fsfw_hal/linux/spi/SpiComIF.h>
+#include <fsfw_hal/linux/spi/SpiCookie.h>
+#include <linux/callbacks/gpioCallbacks.h>
+#include <mission/devices/Max31865PT1000Handler.h>
+#include <mission/devices/SusHandler.h>
+#include <mission/system/RtdFdir.h>
+#include <mission/system/SusAssembly.h>
+#include <mission/system/SusFdir.h>
+#include <mission/system/TcsBoardAssembly.h>
+
+#include "OBSWConfig.h"
+#include "devConf.h"
+#include "devices/addresses.h"
+#include "devices/gpioIds.h"
+
+void ObjectFactory::createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF,
+                                              PowerSwitchIF* pwrSwitcher, std::string spiDev) {
+  using namespace gpio;
+  GpioCookie* gpioCookieSus = new GpioCookie();
+  GpioCallback* susgpio = nullptr;
+
+  susgpio = new GpioCallback("Chip select SUS 0", Direction::OUT, Levels::HIGH,
+                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_0, susgpio);
+  susgpio = new GpioCallback("Chip select SUS 1", Direction::OUT, Levels::HIGH,
+                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_1, susgpio);
+  susgpio = new GpioCallback("Chip select SUS 2", Direction::OUT, Levels::HIGH,
+                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_2, susgpio);
+  susgpio = new GpioCallback("Chip select SUS 3", Direction::OUT, Levels::HIGH,
+                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_3, susgpio);
+  susgpio = new GpioCallback("Chip select SUS 4", Direction::OUT, Levels::HIGH,
+                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_4, susgpio);
+  susgpio = new GpioCallback("Chip select SUS 5", Direction::OUT, Levels::HIGH,
+                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_5, susgpio);
+  susgpio = new GpioCallback("Chip select SUS 6", Direction::OUT, Levels::HIGH,
+                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_6, susgpio);
+  susgpio = new GpioCallback("Chip select SUS 7", Direction::OUT, Levels::HIGH,
+                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_7, susgpio);
+  susgpio = new GpioCallback("Chip select SUS 8", Direction::OUT, Levels::HIGH,
+                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_8, susgpio);
+  susgpio = new GpioCallback("Chip select SUS 9", Direction::OUT, Levels::HIGH,
+                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_9, susgpio);
+  susgpio = new GpioCallback("Chip select SUS 10", Direction::OUT, Levels::HIGH,
+                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_10, susgpio);
+  susgpio = new GpioCallback("Chip select SUS 11", Direction::OUT, Levels::HIGH,
+                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_11, susgpio);
+
+  gpioComIF->addGpios(gpioCookieSus);
+
+#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);
+  susHandlers[0] = new SusHandler(objects::SUS_0, 0, objects::SPI_COM_IF, spiCookie);
+  fdir = new SusFdir(objects::SUS_0);
+  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,
+                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  susHandlers[1] = new SusHandler(objects::SUS_1, 1, objects::SPI_COM_IF, spiCookie);
+  fdir = new SusFdir(objects::SUS_1);
+  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,
+                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  susHandlers[2] = new SusHandler(objects::SUS_2, 2, objects::SPI_COM_IF, spiCookie);
+  fdir = new SusFdir(objects::SUS_2);
+  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,
+                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  susHandlers[3] = new SusHandler(objects::SUS_3, 3, objects::SPI_COM_IF, spiCookie);
+  fdir = new SusFdir(objects::SUS_3);
+  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,
+                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  susHandlers[4] = new SusHandler(objects::SUS_4, 4, objects::SPI_COM_IF, spiCookie);
+  fdir = new SusFdir(objects::SUS_4);
+  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,
+                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  susHandlers[5] = new SusHandler(objects::SUS_5, 5, objects::SPI_COM_IF, spiCookie);
+  fdir = new SusFdir(objects::SUS_5);
+  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,
+                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  susHandlers[6] = new SusHandler(objects::SUS_6, 6, objects::SPI_COM_IF, spiCookie);
+  fdir = new SusFdir(objects::SUS_6);
+  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,
+                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  susHandlers[7] = new SusHandler(objects::SUS_7, 7, objects::SPI_COM_IF, spiCookie);
+  fdir = new SusFdir(objects::SUS_7);
+  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,
+                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  susHandlers[8] = new SusHandler(objects::SUS_8, 8, objects::SPI_COM_IF, spiCookie);
+  fdir = new SusFdir(objects::SUS_8);
+  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,
+                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  susHandlers[9] = new SusHandler(objects::SUS_9, 9, objects::SPI_COM_IF, spiCookie);
+  fdir = new SusFdir(objects::SUS_9);
+  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,
+                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  susHandlers[10] = new SusHandler(objects::SUS_10, 10, objects::SPI_COM_IF, spiCookie);
+  fdir = new SusFdir(objects::SUS_10);
+  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,
+                            spi::SUS_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  susHandlers[11] = new SusHandler(objects::SUS_11, 11, objects::SPI_COM_IF, spiCookie);
+  fdir = new SusFdir(objects::SUS_11);
+  susHandlers[11]->setParent(objects::SUS_BOARD_ASS);
+  susHandlers[11]->setCustomFdir(fdir);
+
+  for (auto& sus : susHandlers) {
+    if (sus != nullptr) {
+#if OBSW_TEST_SUS == 1
+      sus->setStartUpImmediately();
+      sus->setToGoToNormalMode(true);
+#endif
+#if OBSW_DEBUG_SUS == 1
+      sus->enablePeriodicPrintout(true, 3);
+#endif
+    }
+  }
+  std::array<object_id_t, 12> susIds = {objects::SUS_0, objects::SUS_1,  objects::SUS_2,
+                                        objects::SUS_3, objects::SUS_4,  objects::SUS_5,
+                                        objects::SUS_6, objects::SUS_7,  objects::SUS_8,
+                                        objects::SUS_9, objects::SUS_10, objects::SUS_11};
+  SusAssHelper susAssHelper = SusAssHelper(susIds);
+  auto susAss =
+      new SusAssembly(objects::SUS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher, susAssHelper);
+  static_cast<void>(susAss);
+#endif /* OBSW_ADD_SUN_SENSORS == 1 */
+}
+
+void ObjectFactory::createRtdComponents(std::string spiDev, GpioIF* gpioComIF,
+                                        PowerSwitchIF* pwrSwitcher) {
+  using namespace gpio;
+  GpioCookie* rtdGpioCookie = new GpioCookie;
+
+  GpioCallback* gpioRtdIc0 = new GpioCallback("Chip select RTD IC0", Direction::OUT, Levels::HIGH,
+                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_3, gpioRtdIc0);
+  GpioCallback* gpioRtdIc1 = new GpioCallback("Chip select RTD IC1", Direction::OUT, Levels::HIGH,
+                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_4, gpioRtdIc1);
+  GpioCallback* gpioRtdIc2 = new GpioCallback("Chip select RTD IC2", Direction::OUT, Levels::HIGH,
+                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_5, gpioRtdIc2);
+  GpioCallback* gpioRtdIc3 = new GpioCallback("Chip select RTD IC3", Direction::OUT, Levels::HIGH,
+                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_6, gpioRtdIc3);
+  GpioCallback* gpioRtdIc4 = new GpioCallback("Chip select RTD IC4", Direction::OUT, Levels::HIGH,
+                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_7, gpioRtdIc4);
+  GpioCallback* gpioRtdIc5 = new GpioCallback("Chip select RTD IC5", Direction::OUT, Levels::HIGH,
+                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_8, gpioRtdIc5);
+  GpioCallback* gpioRtdIc6 = new GpioCallback("Chip select RTD IC6", Direction::OUT, Levels::HIGH,
+                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_9, gpioRtdIc6);
+  GpioCallback* gpioRtdIc7 = new GpioCallback("Chip select RTD IC7", Direction::OUT, Levels::HIGH,
+                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_10, gpioRtdIc7);
+  GpioCallback* gpioRtdIc8 = new GpioCallback("Chip select RTD IC8", Direction::OUT, Levels::HIGH,
+                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_11, gpioRtdIc8);
+  GpioCallback* gpioRtdIc9 = new GpioCallback("Chip select RTD IC9", Direction::OUT, Levels::HIGH,
+                                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_12, gpioRtdIc9);
+  GpioCallback* gpioRtdIc10 = new GpioCallback("Chip select RTD IC10", Direction::OUT, Levels::HIGH,
+                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_13, gpioRtdIc10);
+  GpioCallback* gpioRtdIc11 = new GpioCallback("Chip select RTD IC11", Direction::OUT, Levels::HIGH,
+                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_14, gpioRtdIc11);
+  GpioCallback* gpioRtdIc12 = new GpioCallback("Chip select RTD IC12", Direction::OUT, Levels::HIGH,
+                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_15, gpioRtdIc12);
+  GpioCallback* gpioRtdIc13 = new GpioCallback("Chip select RTD IC13", Direction::OUT, Levels::HIGH,
+                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_16, gpioRtdIc13);
+  GpioCallback* gpioRtdIc14 = new GpioCallback("Chip select RTD IC14", Direction::OUT, Levels::HIGH,
+                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_17, gpioRtdIc14);
+  GpioCallback* gpioRtdIc15 = new GpioCallback("Chip select RTD IC15", Direction::OUT, Levels::HIGH,
+                                               &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  rtdGpioCookie->addGpio(gpioIds::RTD_IC_18, gpioRtdIc15);
+
+  gpioComIF->addGpios(rtdGpioCookie);
+
+#if OBSW_ADD_RTD_DEVICES == 1
+  static constexpr uint8_t NUMBER_RTDS = 16;
+  std::array<std::pair<address_t, gpioId_t>, NUMBER_RTDS> cookieArgs = {{
+      {addresses::RTD_IC_3, gpioIds::RTD_IC_3},
+      {addresses::RTD_IC_4, gpioIds::RTD_IC_4},
+      {addresses::RTD_IC_5, gpioIds::RTD_IC_5},
+      {addresses::RTD_IC_6, gpioIds::RTD_IC_6},
+      {addresses::RTD_IC_7, gpioIds::RTD_IC_7},
+      {addresses::RTD_IC_8, gpioIds::RTD_IC_8},
+      {addresses::RTD_IC_9, gpioIds::RTD_IC_9},
+      {addresses::RTD_IC_10, gpioIds::RTD_IC_10},
+      {addresses::RTD_IC_11, gpioIds::RTD_IC_11},
+      {addresses::RTD_IC_12, gpioIds::RTD_IC_12},
+      {addresses::RTD_IC_13, gpioIds::RTD_IC_13},
+      {addresses::RTD_IC_14, gpioIds::RTD_IC_14},
+      {addresses::RTD_IC_15, gpioIds::RTD_IC_15},
+      {addresses::RTD_IC_16, gpioIds::RTD_IC_16},
+      {addresses::RTD_IC_17, gpioIds::RTD_IC_17},
+      {addresses::RTD_IC_18, gpioIds::RTD_IC_18},
+  }};
+  std::array<object_id_t, NUMBER_RTDS> rtdIds = {
+      objects::RTD_IC_3,  objects::RTD_IC_4,  objects::RTD_IC_5,  objects::RTD_IC_6,
+      objects::RTD_IC_7,  objects::RTD_IC_8,  objects::RTD_IC_9,  objects::RTD_IC_10,
+      objects::RTD_IC_11, objects::RTD_IC_12, objects::RTD_IC_13, objects::RTD_IC_14,
+      objects::RTD_IC_15, objects::RTD_IC_16, objects::RTD_IC_17, objects::RTD_IC_18};
+  std::array<SpiCookie*, NUMBER_RTDS> rtdCookies = {};
+  std::array<Max31865PT1000Handler*, NUMBER_RTDS> rtds = {};
+  RtdFdir* rtdFdir = nullptr;
+  for (uint8_t idx = 0; idx < NUMBER_RTDS; idx++) {
+    rtdCookies[idx] =
+        new SpiCookie(cookieArgs[idx].first, cookieArgs[idx].second, spiDev,
+                      Max31865Definitions::MAX_REPLY_SIZE, spi::RTD_MODE, spi::RTD_SPEED);
+    rtds[idx] = new Max31865PT1000Handler(rtdIds[idx], objects::SPI_COM_IF, rtdCookies[idx]);
+    rtds[idx]->setParent(objects::TCS_BOARD_ASS);
+    rtdFdir = new RtdFdir(rtdIds[idx]);
+    rtds[idx]->setCustomFdir(rtdFdir);
+    rtds[idx]->setDeviceIdx(idx + 3);
+  }
+
+#if OBSW_TEST_RTD == 1
+  for (auto& rtd : rtds) {
+    if (rtd != nullptr) {
+      rtd->setStartUpImmediately();
+      rtd->setInstantNormal(true);
+    }
+  }
+#endif  // OBSW_TEST_RTD == 1
+  TcsBoardHelper helper(rtdIds);
+  TcsBoardAssembly* tcsBoardAss =
+      new TcsBoardAssembly(objects::TCS_BOARD_ASS, objects::NO_OBJECT, pwrSwitcher,
+                           pcduSwitches::Switches::PDU1_CH0_TCS_BOARD_3V3, helper);
+  static_cast<void>(tcsBoardAss);
+#endif  // OBSW_ADD_RTD_DEVICES == 1
+}

linux/ObjectFactory.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <string>
+
+class GpioIF;
+class SpiComIF;
+class PowerSwitchIF;
+
+namespace ObjectFactory {
+
+void createSunSensorComponents(GpioIF* gpioComIF, SpiComIF* spiComIF, PowerSwitchIF* pwrSwitcher,
+                               std::string spiDev);
+void createRtdComponents(std::string spiDev, GpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher);
+
+}  // namespace ObjectFactory

linux/boardtest/SpiTestClass.h

@@ -3,9 +3,14 @@
 
 #include "OBSWConfig.h"
 
-#if defined(XIPHOS_Q7S)
+#ifdef XIPHOS_Q7S
 #include "busConf.h"
 #endif
+
+#ifdef RASPBERRY_PI
+#include <bsp_linux_board/definitions.h>
+#endif
+
 #include <fsfw_hal/common/gpio/GpioIF.h>
 #include <fsfw_hal/linux/spi/SpiCookie.h>
 #include <test/testtasks/TestTask.h>

linux/callbacks/CMakeLists.txt

@@ -0,0 +1,3 @@
+target_sources(${OBSW_NAME} PRIVATE
+	gpioCallbacks.cpp
+)

linux/callbacks/gpioCallbacks.cpp

@@ -0,0 +1,431 @@
+#include "gpioCallbacks.h"
+
+#include "devices/gpioIds.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw_hal/common/gpio/GpioCookie.h"
+#include "fsfw_hal/common/gpio/GpioIF.h"
+
+void gpioCallbacks::spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp,
+                                         gpio::Levels value, void* args) {
+  GpioIF* gpioIF = reinterpret_cast<GpioIF*>(args);
+  if (gpioIF == nullptr) {
+    sif::debug << "spiCsDecoderCallback: No gpioComIF specified. Call initSpiCsDecoder "
+               << "to specify gpioComIF" << std::endl;
+    return;
+  }
+
+  /* Reading is not supported by the callback function */
+  if (gpioOp == gpio::GpioOperation::READ) {
+    return;
+  }
+
+  if (value == gpio::Levels::HIGH) {
+    switch (gpioId) {
+      case (gpioIds::RTD_IC_3): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_4): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_5): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_6): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_7): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_8): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_9): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_10): {
+        disableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_11): {
+        disableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_12): {
+        disableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_13): {
+        disableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_14): {
+        disableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_15): {
+        disableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_16): {
+        disableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_17): {
+        disableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_18): {
+        disableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_0): {
+        disableDecoderInterfaceBoardIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_1): {
+        disableDecoderInterfaceBoardIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_2): {
+        disableDecoderInterfaceBoardIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_3): {
+        disableDecoderInterfaceBoardIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_4): {
+        disableDecoderInterfaceBoardIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_5): {
+        disableDecoderInterfaceBoardIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_6): {
+        disableDecoderInterfaceBoardIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_7): {
+        disableDecoderInterfaceBoardIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_8): {
+        disableDecoderInterfaceBoardIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_9): {
+        disableDecoderInterfaceBoardIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_10): {
+        disableDecoderInterfaceBoardIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_11): {
+        disableDecoderInterfaceBoardIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_RW1): {
+        disableRwDecoder(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_RW2): {
+        disableRwDecoder(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_RW3): {
+        disableRwDecoder(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_RW4): {
+        disableRwDecoder(gpioIF);
+        break;
+      }
+      default:
+        sif::debug << "spiCsDecoderCallback: Invalid gpio id " << gpioId << std::endl;
+    }
+  } else if (value == gpio::Levels::LOW) {
+    switch (gpioId) {
+      case (gpioIds::RTD_IC_3): {
+        selectY7(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_4): {
+        selectY6(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_5): {
+        selectY5(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_6): {
+        selectY4(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_7): {
+        selectY3(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_8): {
+        selectY2(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_9): {
+        selectY1(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_10): {
+        selectY0(gpioIF);
+        enableDecoderTcsIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_11): {
+        selectY7(gpioIF);
+        enableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_12): {
+        selectY6(gpioIF);
+        enableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_13): {
+        selectY5(gpioIF);
+        enableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_14): {
+        selectY4(gpioIF);
+        enableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_15): {
+        selectY3(gpioIF);
+        enableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_16): {
+        selectY2(gpioIF);
+        enableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_17): {
+        selectY1(gpioIF);
+        enableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::RTD_IC_18): {
+        selectY0(gpioIF);
+        enableDecoderTcsIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_0): {
+        selectY0(gpioIF);
+        enableDecoderInterfaceBoardIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_1): {
+        selectY1(gpioIF);
+        enableDecoderInterfaceBoardIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_2): {
+        selectY2(gpioIF);
+        enableDecoderInterfaceBoardIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_3): {
+        selectY3(gpioIF);
+        enableDecoderInterfaceBoardIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_4): {
+        selectY4(gpioIF);
+        enableDecoderInterfaceBoardIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_5): {
+        selectY5(gpioIF);
+        enableDecoderInterfaceBoardIc1(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_6): {
+        selectY0(gpioIF);
+        enableDecoderInterfaceBoardIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_7): {
+        selectY1(gpioIF);
+        enableDecoderInterfaceBoardIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_8): {
+        selectY2(gpioIF);
+        enableDecoderInterfaceBoardIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_9): {
+        selectY3(gpioIF);
+        enableDecoderInterfaceBoardIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_10): {
+        selectY4(gpioIF);
+        enableDecoderInterfaceBoardIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_SUS_11): {
+        selectY5(gpioIF);
+        enableDecoderInterfaceBoardIc2(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_RW1): {
+        selectY0(gpioIF);
+        enableRwDecoder(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_RW2): {
+        selectY1(gpioIF);
+        enableRwDecoder(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_RW3): {
+        selectY2(gpioIF);
+        enableRwDecoder(gpioIF);
+        break;
+      }
+      case (gpioIds::CS_RW4): {
+        selectY3(gpioIF);
+        enableRwDecoder(gpioIF);
+        break;
+      }
+      default:
+        sif::debug << "spiCsDecoderCallback: Invalid gpio id " << gpioId << std::endl;
+    }
+  } else {
+    sif::debug << "spiCsDecoderCallback: Invalid value. Must be 0 or 1" << std::endl;
+  }
+}
+
+void gpioCallbacks::enableDecoderTcsIc1(GpioIF* gpioIF) {
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_0);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_1);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_2);
+}
+
+void gpioCallbacks::enableDecoderTcsIc2(GpioIF* gpioIF) {
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_2);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_0);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_1);
+}
+
+void gpioCallbacks::enableDecoderInterfaceBoardIc1(GpioIF* gpioIF) {
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_0);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_1);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_2);
+}
+
+void gpioCallbacks::enableDecoderInterfaceBoardIc2(GpioIF* gpioIF) {
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_0);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_1);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_2);
+}
+
+void gpioCallbacks::disableDecoderTcsIc1(GpioIF* gpioIF) {
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_0);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_1);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_2);
+}
+
+void gpioCallbacks::disableDecoderTcsIc2(GpioIF* gpioIF) {
+  // DO NOT CHANGE THE ORDER HERE
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_0);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_2);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_1);
+}
+
+void gpioCallbacks::disableDecoderInterfaceBoardIc1(GpioIF* gpioIF) {
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_0);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_1);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_2);
+}
+
+void gpioCallbacks::disableDecoderInterfaceBoardIc2(GpioIF* gpioIF) {
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_0);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_1);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_2);
+}
+
+void gpioCallbacks::enableRwDecoder(GpioIF* gpioIF) { gpioIF->pullHigh(gpioIds::EN_RW_CS); }
+
+void gpioCallbacks::disableRwDecoder(GpioIF* gpioIF) { gpioIF->pullLow(gpioIds::EN_RW_CS); }
+
+void gpioCallbacks::selectY0(GpioIF* gpioIF) {
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_3);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_4);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_5);
+}
+
+void gpioCallbacks::selectY1(GpioIF* gpioIF) {
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_3);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_4);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_5);
+}
+
+void gpioCallbacks::selectY2(GpioIF* gpioIF) {
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_3);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_4);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_5);
+}
+
+void gpioCallbacks::selectY3(GpioIF* gpioIF) {
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_3);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_4);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_5);
+}
+
+void gpioCallbacks::selectY4(GpioIF* gpioIF) {
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_3);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_4);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_5);
+}
+
+void gpioCallbacks::selectY5(GpioIF* gpioIF) {
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_3);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_4);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_5);
+}
+
+void gpioCallbacks::selectY6(GpioIF* gpioIF) {
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_3);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_4);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_5);
+}
+
+void gpioCallbacks::selectY7(GpioIF* gpioIF) {
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_3);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_4);
+  gpioIF->pullHigh(gpioIds::SPI_MUX_BIT_5);
+}
+
+void gpioCallbacks::disableAllDecoder(GpioIF* gpioIF) {
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_2);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_0);
+  gpioIF->pullLow(gpioIds::SPI_MUX_BIT_1);
+  gpioIF->pullLow(gpioIds::EN_RW_CS);
+}

linux/callbacks/gpioCallbacks.h

@@ -1,16 +1,10 @@
-#ifndef LINUX_GPIO_GPIOCALLBACKS_H_
+#pragma once
-#define LINUX_GPIO_GPIOCALLBACKS_H_
 
-#include <fsfw_hal/common/gpio/GpioIF.h>
 #include <fsfw_hal/common/gpio/gpioDefinitions.h>
 
-namespace gpioCallbacks {
+class GpioIF;
 
-/**
+namespace gpioCallbacks {
- * @brief   This function initializes the GPIOs used to control the SN74LVC138APWR decoders on
- *          the TCS Board and the interface board.
- */
-void initSpiCsDecoder(GpioIF* gpioComIF);
 
 /**
  * @brief   This function implements the decoding to multiply gpios by using the decoder
@@ -23,51 +17,50 @@ void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Lev
  * @brief   This function sets mux bits 1-3 to a state which will only enable the decoder
  *          on the TCS board which is named to IC1 in the schematic.
  */
-void enableDecoderTcsIc1();
+void enableDecoderTcsIc1(GpioIF* gpioIF);
 
 /**
  * @brief   This function sets mux bits 1-3 to a state which will only enable the decoder
  *          on the TCS board which is named to IC2 in the schematic.
  */
-void enableDecoderTcsIc2();
+void enableDecoderTcsIc2(GpioIF* gpioIF);
 
 /**
  * @brief   This function sets mux bits 1-3 to a state which will only enable the decoder
  *          on the inteface board board which is named to IC21 in the schematic.
  */
-void enableDecoderInterfaceBoardIc1();
+void enableDecoderInterfaceBoardIc1(GpioIF* gpioIF);
 
 /**
  * @brief   This function sets mux bits 1-3 to a state which will only enable the decoder
  *          on the inteface board board which is named to IC22 in the schematic.
  */
-void enableDecoderInterfaceBoardIc2();
+void enableDecoderInterfaceBoardIc2(GpioIF* gpioIF);
 
-void disableDecoderTcsIc1();
+void disableDecoderTcsIc1(GpioIF* gpioIF);
-void disableDecoderTcsIc2();
+void disableDecoderTcsIc2(GpioIF* gpioIF);
-void disableDecoderInterfaceBoardIc1();
+void disableDecoderInterfaceBoardIc1(GpioIF* gpioIF);
-void disableDecoderInterfaceBoardIc2();
+void disableDecoderInterfaceBoardIc2(GpioIF* gpioIF);
 
 /**
  * @brief   Enables the reaction wheel chip select decoder (IC3).
  */
-void enableRwDecoder();
+void enableRwDecoder(GpioIF* gpioIF);
-void disableRwDecoder();
+void disableRwDecoder(GpioIF* gpioIF);
 
 /**
  * @brief   This function disables all decoder.
  */
-void disableAllDecoder();
+void disableAllDecoder(GpioIF* gpioIF);
 
 /** The following functions enable the appropriate channel of the currently enabled decoder */
-void selectY0();
+void selectY0(GpioIF* gpioIF);
-void selectY1();
+void selectY1(GpioIF* gpioIF);
-void selectY2();
+void selectY2(GpioIF* gpioIF);
-void selectY3();
+void selectY3(GpioIF* gpioIF);
-void selectY4();
+void selectY4(GpioIF* gpioIF);
-void selectY5();
+void selectY5(GpioIF* gpioIF);
-void selectY6();
+void selectY6(GpioIF* gpioIF);
-void selectY7();
+void selectY7(GpioIF* gpioIF);
-}  // namespace gpioCallbacks
 
-#endif /* LINUX_GPIO_GPIOCALLBACKS_H_ */
+}  // namespace gpioCallbacks

linux/fsfwconfig/OBSWConfig.h.in

@@ -51,7 +51,7 @@ debugging. */
 #define OBSW_ADD_RTD_DEVICES                        1
 #define OBSW_ADD_TMP_DEVICES                        0
 #define OBSW_ADD_RAD_SENSORS                        1
-#define OBSW_ADD_PL_PCDU                            0
+#define OBSW_ADD_PL_PCDU                            1
 #define OBSW_ADD_SYRLINKS                           0
 #define OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT       0
 #define OBSW_STAR_TRACKER_GROUND_CONFIG             1
@@ -170,6 +170,7 @@ debugging. */
 #define OBSW_ADD_SUN_SENSORS                        0
 #define OBSW_ADD_MGT                                0
 #define OBSW_ADD_ACS_BOARD                          0
+#define OBSW_ADD_ACS_HANDLERS                       0
 #define OBSW_ADD_GPS_0                              0
 #define OBSW_ADD_GPS_1                              0
 #define OBSW_ADD_RW                                 0

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -165,17 +165,17 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
 
 #if OBSW_ADD_SUN_SENSORS == 1
 
-  bool addSus0 = true;
+  bool addSus0 = false;
-  bool addSus1 = true;
+  bool addSus1 = false;
-  bool addSus2 = true;
+  bool addSus2 = false;
-  bool addSus3 = true;
+  bool addSus3 = false;
-  bool addSus4 = true;
+  bool addSus4 = false;
-  bool addSus5 = true;
+  bool addSus5 = false;
-  bool addSus6 = true;
+  bool addSus6 = false;
-  bool addSus7 = true;
+  bool addSus7 = false;
-  bool addSus8 = true;
+  bool addSus8 = false;
-  bool addSus9 = true;
+  bool addSus9 = false;
-  bool addSus10 = true;
+  bool addSus10 = false;
   bool addSus11 = true;
 
   if (addSus0) {

mission/devices/HeaterHandler.cpp

@@ -164,7 +164,7 @@ ReturnValue_t HeaterHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t o
                  << "message" << std::endl;
     }
   }
-  return RETURN_OK;
+  return result;
 }
 
 void HeaterHandler::handleActiveCommands() {

mission/devices/PCDUHandler.cpp

@@ -347,7 +347,7 @@ ReturnValue_t PCDUHandler::sendSwitchCommand(uint8_t switchNr, ReturnValue_t onO
     // Can't use trigger event because of const function constraint, but this hack seems to work
     this->forwardEvent(power::SWITCH_CMD_SENT, parameterValue, switchNr);
   }
-  return RETURN_OK;
+  return result;
 }
 
 ReturnValue_t PCDUHandler::sendFuseOnCommand(uint8_t fuseNr) { return RETURN_OK; }

mission/devices/PayloadPcduHandler.cpp

@@ -14,19 +14,69 @@
 
 PayloadPcduHandler::PayloadPcduHandler(object_id_t objectId, object_id_t comIF, CookieIF* cookie,
                                        GpioIF* gpioIF, SdCardMountedIF* sdcMan,
-                                       bool periodicPrintout)
+                                       PowerSwitchIF* pwrSwitcher, power::Switch_t switchA,
+                                       power::Switch_t switchB, bool periodicPrintout)
     : DeviceHandlerBase(objectId, comIF, cookie),
       adcSet(this),
       periodicPrintout(periodicPrintout),
       gpioIF(gpioIF),
-      sdcMan(sdcMan) {}
+      sdcMan(sdcMan),
+      pwrStateMachine(switchA, switchB, pwrSwitcher) {}
 
 void PayloadPcduHandler::doStartUp() {
-  if ((state != States::PCDU_OFF) and (state != States::ON_TRANS_SSR)) {
+  if ((state != States::PL_PCDU_OFF) and (state != States::ON_TRANS_SSR)) {
     // Config error
     sif::error << "PayloadPcduHandler::doStartUp: Invalid state" << std::endl;
   }
-  if (state == States::PCDU_OFF) {
+  if (pwrStateMachine.getState() == power::States::IDLE) {
+    pwrStateMachine.start(MODE_ON, pwrSubmode);
+  }
+  auto opCode = pwrStateMachine.fsm();
+  if (opCode == power::OpCodes::TO_NOT_OFF_DONE or opCode == power::OpCodes::TIMEOUT_OCCURED) {
+    pwrStateMachine.reset();
+    quickTransitionAlreadyCalled = false;
+    state = States::POWER_CHANNELS_ON;
+    setMode(_MODE_TO_ON);
+  }
+}
+
+void PayloadPcduHandler::doShutDown() {
+  if (not quickTransitionAlreadyCalled) {
+    quickTransitionBackToOff(false, false);
+    quickTransitionAlreadyCalled = true;
+  }
+  if (pwrStateMachine.getState() == power::States::IDLE) {
+    pwrStateMachine.start(MODE_OFF, 0);
+  }
+  auto opCode = pwrStateMachine.fsm();
+  if (opCode == power::OpCodes::TO_OFF_DONE or opCode == power::OpCodes::TIMEOUT_OCCURED) {
+    pwrStateMachine.reset();
+    // No need to set mode _MODE_POWER_DOWN, power switching was already handled
+    setMode(MODE_OFF);
+  }
+}
+
+void PayloadPcduHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
+  if (mode == _MODE_TO_NORMAL) {
+    stateMachineToNormal(modeFrom, subModeFrom);
+    return;
+  }
+  DeviceHandlerBase::doTransition(modeFrom, subModeFrom);
+}
+
+ReturnValue_t PayloadPcduHandler::stateMachineToNormal(Mode_t modeFrom, Submode_t subModeFrom) {
+  using namespace plpcdu;
+  if (submode == NormalSubmodes::SOLID_STATE_RELAYS_ADC_ON) {
+    if (state == States::PL_PCDU_OFF) {
+      sif::error << "PayloadPcduHandler::stateMachineToNormal: Unexpected state PL_PCDU_OFF"
+                 << "detected" << std::endl;
+      setMode(MODE_OFF);
+      return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    if (state == States::POWER_CHANNELS_ON) {
+#if OBSW_VERBOSE_LEVEL >= 1
+      sif::info << "Switching on SSR VBAT0 & VBAT1 GPIOs" << std::endl;
+#endif
       // Switch on relays here
       gpioIF->pullHigh(gpioIds::PLPCDU_ENB_VBAT0);
       gpioIF->pullHigh(gpioIds::PLPCDU_ENB_VBAT1);
@@ -38,20 +88,15 @@ void PayloadPcduHandler::doStartUp() {
       if (transitionOk) {
         transitionOk = false;
         state = States::ON_TRANS_ADC_CLOSE_ZERO;
-      // We are now in ON mode
+
-      startTransition(MODE_NORMAL, 0);
         adcCountdown.setTimeout(50);
         adcCountdown.resetTimer();
         adcState = AdcStates::BOOT_DELAY;
-      // The ADC can now be read. If the values are not close to zero, we should not allow
+        // If the values are not close to zero, we should not allow transition
-      // transition
         monMode = MonitoringMode::CLOSE_TO_ZERO;
       }
     }
-}
+    if (state == States::ON_TRANS_ADC_CLOSE_ZERO) {
-
-void PayloadPcduHandler::stateMachineToNormal() {
-  using namespace plpcdu;
       if (adcState == AdcStates::BOOT_DELAY) {
         if (adcCountdown.hasTimedOut()) {
           adcState = AdcStates::SEND_SETUP;
@@ -61,38 +106,17 @@ void PayloadPcduHandler::stateMachineToNormal() {
       if (adcState == AdcStates::SEND_SETUP) {
         if (adcCmdExecuted) {
           adcState = AdcStates::NORMAL;
-      setMode(MODE_NORMAL, NORMAL_ADC_ONLY);
           adcCountdown.setTimeout(100);
           adcCountdown.resetTimer();
           adcCmdExecuted = false;
+          setMode(MODE_NORMAL, submode);
+          return HasReturnvaluesIF::RETURN_OK;
         }
       }
-  if (submode == plpcdu::NORMAL_ALL_ON) {
-    if (state == States::ON_TRANS_ADC_CLOSE_ZERO) {
-      if (not commandExecuted) {
-        float waitTime = DFT_SSR_TO_DRO_WAIT_TIME;
-        params.getValue(PARAM_KEY_MAP[SSR_TO_DRO_WAIT_TIME], waitTime);
-        countdown.setTimeout(std::round(waitTime * 1000));
-        countdown.resetTimer();
-        commandExecuted = true;
-        // TODO: For now, skip ADC check
-        transitionOk = true;
-      }
-      // ADC values are ok, 5 seconds have elapsed
-      if (transitionOk and countdown.hasTimedOut()) {
-        state = States::ON_TRANS_DRO;
-        // Now start monitoring for negative voltages instead
-        monMode = MonitoringMode::NEGATIVE;
-        commandExecuted = false;
-        transitionOk = false;
     }
   }
-    if (state == States::ON_TRANS_DRO) {
+
-      if (not commandExecuted) {
+  if (submode == NormalSubmodes::DRO_ON) {
-        float waitTime = DFT_DRO_TO_X8_WAIT_TIME;
-        params.getValue(PARAM_KEY_MAP[DRO_TO_X8_WAIT_TIME], waitTime);
-        countdown.setTimeout(std::round(waitTime * 1000));
-        countdown.resetTimer();
 #if OBSW_VERBOSE_LEVEL >= 1
     sif::info << "Enabling PL PCDU DRO module" << std::endl;
 #endif
@@ -100,112 +124,55 @@ void PayloadPcduHandler::stateMachineToNormal() {
     gpioIF->pullHigh(gpioIds::PLPCDU_ENB_DRO);
     adcCountdown.setTimeout(100);
     adcCountdown.resetTimer();
-        commandExecuted = true;
+    setMode(MODE_NORMAL, submode);
   }
-      // ADC values are ok, 5 seconds have elapsed
+
-      if (transitionOk and countdown.hasTimedOut()) {
+  if (submode == NormalSubmodes::X8_ON) {
-        state = States::ON_TRANS_X8;
-        commandExecuted = false;
-        transitionOk = false;
-      }
-    }
-    if (state == States::ON_TRANS_X8) {
-      if (not commandExecuted) {
-        float waitTime = DFT_X8_TO_TX_WAIT_TIME;
-        params.getValue(PARAM_KEY_MAP[X8_TO_TX_WAIT_TIME], waitTime);
-        countdown.setTimeout(std::round(waitTime * 1000));
-        countdown.resetTimer();
 #if OBSW_VERBOSE_LEVEL >= 1
     sif::info << "Enabling PL PCDU X8 module" << std::endl;
 #endif
-        // Switch on X8
+    // Switch on DRO and start monitoring for negative voltages
     gpioIF->pullHigh(gpioIds::PLPCDU_ENB_X8);
     adcCountdown.setTimeout(100);
     adcCountdown.resetTimer();
-        commandExecuted = true;
+    setMode(MODE_NORMAL, submode);
   }
-      // ADC values are ok, 5 seconds have elapsed
+
-      if (transitionOk and countdown.hasTimedOut()) {
+  if (submode == NormalSubmodes::TX_ON) {
-        state = States::ON_TRANS_TX;
-        commandExecuted = false;
-        transitionOk = false;
-      }
-    }
-    if (state == States::ON_TRANS_TX) {
-      if (not commandExecuted) {
-        float waitTime = DFT_TX_TO_MPA_WAIT_TIME;
-        params.getValue(PARAM_KEY_MAP[TX_TO_MPA_WAIT_TIME], waitTime);
-        countdown.setTimeout(std::round(waitTime * 1000));
-        countdown.resetTimer();
 #if OBSW_VERBOSE_LEVEL >= 1
     sif::info << "Enabling PL PCDU TX module" << std::endl;
 #endif
-        // Switch on TX
+    // Switch on DRO and start monitoring for negative voltages
     gpioIF->pullHigh(gpioIds::PLPCDU_ENB_TX);
-        // Wait for 100 ms before checking ADC values
     adcCountdown.setTimeout(100);
     adcCountdown.resetTimer();
-        commandExecuted = true;
+    setMode(MODE_NORMAL, submode);
   }
-      // ADC values are ok, 5 seconds have elapsed
+
-      if (transitionOk and countdown.hasTimedOut()) {
+  if (submode == NormalSubmodes::MPA_ON) {
-        state = States::ON_TRANS_MPA;
-        commandExecuted = false;
-        transitionOk = false;
-      }
-    }
-    if (state == States::ON_TRANS_MPA) {
-      if (not commandExecuted) {
-        float waitTime = DFT_MPA_TO_HPA_WAIT_TIME;
-        params.getValue(PARAM_KEY_MAP[MPA_TO_HPA_WAIT_TIME], waitTime);
-        countdown.setTimeout(std::round(waitTime * 1000));
-        countdown.resetTimer();
 #if OBSW_VERBOSE_LEVEL >= 1
     sif::info << "Enabling PL PCDU MPA module" << std::endl;
 #endif
-        // Switch on MPA
+    // Switch on DRO and start monitoring for negative voltages
     gpioIF->pullHigh(gpioIds::PLPCDU_ENB_MPA);
-        // Wait for 100 ms before checking ADC values
     adcCountdown.setTimeout(100);
     adcCountdown.resetTimer();
-        commandExecuted = true;
+    setMode(MODE_NORMAL, submode);
   }
-      // ADC values are ok, 5 seconds have elapsed
+
-      if (transitionOk and countdown.hasTimedOut()) {
+  if (submode == NormalSubmodes::HPA_ON) {
-        state = States::ON_TRANS_HPA;
-        commandExecuted = false;
-        transitionOk = false;
-      }
-    }
-    if (state == States::ON_TRANS_HPA) {
-      if (not commandExecuted) {
-        // Switch on HPA
-        gpioIF->pullHigh(gpioIds::PLPCDU_ENB_HPA);
 #if OBSW_VERBOSE_LEVEL >= 1
     sif::info << "Enabling PL PCDU HPA module" << std::endl;
 #endif
-        commandExecuted = true;
+    // Switch on DRO and start monitoring for negative voltages
-      }
+    gpioIF->pullHigh(gpioIds::PLPCDU_ENB_HPA);
-      // ADC values are ok, 5 seconds have elapsed
+    adcCountdown.setTimeout(100);
-      if (transitionOk and countdown.hasTimedOut()) {
+    adcCountdown.resetTimer();
-        state = States::PCDU_ON;
+    setMode(MODE_NORMAL, submode);
-        setMode(MODE_NORMAL, plpcdu::NORMAL_ALL_ON);
-        countdown.resetTimer();
-        commandExecuted = false;
-        transitionOk = false;
-      }
-    }
   }
+  return RETURN_OK;
 }
 
-void PayloadPcduHandler::doTransition(Mode_t modeFrom, Submode_t subModeFrom) {
-  if (mode == _MODE_TO_NORMAL) {
-    stateMachineToNormal();
-  }
-}
-
-void PayloadPcduHandler::doShutDown() { transitionBackToOff(false); }
-
 ReturnValue_t PayloadPcduHandler::buildNormalDeviceCommand(DeviceCommandId_t* id) {
   switch (adcState) {
     case (AdcStates::SEND_SETUP): {
@@ -388,7 +355,7 @@ void PayloadPcduHandler::enablePeriodicPrintout(bool enable, uint8_t divider) {
   opDivider.setDivider(divider);
 }
 
-void PayloadPcduHandler::transitionBackToOff(bool notifyFdir) {
+void PayloadPcduHandler::quickTransitionBackToOff(bool startTransitionToOff, bool notifyFdir) {
   States currentState = state;
   gpioIF->pullLow(gpioIds::PLPCDU_ENB_HPA);
   gpioIF->pullLow(gpioIds::PLPCDU_ENB_MPA);
@@ -398,9 +365,11 @@ void PayloadPcduHandler::transitionBackToOff(bool notifyFdir) {
   gpioIF->pullLow(gpioIds::PLPCDU_ENB_TX);
   gpioIF->pullLow(gpioIds::PLPCDU_ENB_VBAT0);
   gpioIF->pullLow(gpioIds::PLPCDU_ENB_VBAT1);
-  state = States::PCDU_OFF;
+  state = States::PL_PCDU_OFF;
   adcState = AdcStates::OFF;
-  setMode(MODE_OFF);
+  if (startTransitionToOff) {
+    startTransition(MODE_OFF, 0);
+  }
   if (notifyFdir) {
     triggerEvent(TRANSITION_BACK_TO_OFF, static_cast<uint32_t>(currentState));
   }
@@ -556,7 +525,8 @@ bool PayloadPcduHandler::checkVoltage(float val, float lowerBound, float upperBo
     serializeFloat(p2, val);
     triggerEvent(event, tooLarge, p2);
     transitionOk = false;
-    transitionBackToOff(true);
+    quickTransitionBackToOff(true, true);
+    quickTransitionAlreadyCalled = true;
     return false;
   }
   return true;
@@ -568,14 +538,37 @@ bool PayloadPcduHandler::checkCurrent(float val, float upperBound, Event event)
     serializeFloat(p2, val);
     triggerEvent(event, true, p2);
     transitionOk = false;
-    transitionBackToOff(true);
+    quickTransitionBackToOff(true, true);
+    quickTransitionAlreadyCalled = true;
     return false;
   }
   return true;
 }
 
 ReturnValue_t PayloadPcduHandler::isModeCombinationValid(Mode_t mode, Submode_t submode) {
-  if (mode == MODE_NORMAL and submode <= 1) {
+  using namespace plpcdu;
+  if (mode == MODE_NORMAL) {
+    // Also deals with the case where the mode is MODE_ON, submode should be 0 here
+    if (submode == NormalSubmodes::SOLID_STATE_RELAYS_ADC_ON and
+        (this->mode == MODE_NORMAL and this->submode != NormalSubmodes::ALL_OFF)) {
+      return TRANS_NOT_ALLOWED;
+    }
+    if ((submode == NormalSubmodes::DRO_ON and
+         this->submode != NormalSubmodes::SOLID_STATE_RELAYS_ADC_ON)) {
+      return TRANS_NOT_ALLOWED;
+    }
+    if ((submode == NormalSubmodes::X8_ON and this->submode != NormalSubmodes::DRO_ON)) {
+      return TRANS_NOT_ALLOWED;
+    }
+    if ((submode == NormalSubmodes::TX_ON and this->submode != NormalSubmodes::X8_ON)) {
+      return TRANS_NOT_ALLOWED;
+    }
+    if ((submode == NormalSubmodes::MPA_ON and this->submode != NormalSubmodes::TX_ON)) {
+      return TRANS_NOT_ALLOWED;
+    }
+    if ((submode == NormalSubmodes::HPA_ON and this->submode != NormalSubmodes::MPA_ON)) {
+      return TRANS_NOT_ALLOWED;
+    }
     return HasReturnvaluesIF::RETURN_OK;
   }
   return DeviceHandlerBase::isModeCombinationValid(mode, submode);
@@ -658,7 +651,8 @@ void PayloadPcduHandler::handleFailureInjection(std::string output, Event event)
             << std::endl;
   triggerEvent(event, 0, 0);
   transitionOk = false;
-  transitionBackToOff(true);
+  quickTransitionBackToOff(true, true);
+  quickTransitionAlreadyCalled = true;
   droToX8InjectionRequested = false;
 }
 

mission/devices/PayloadPcduHandler.h

@@ -10,6 +10,8 @@
 #include "fsfw_hal/common/gpio/GpioIF.h"
 #include "mission/devices/devicedefinitions/payloadPcduDefinitions.h"
 #include "mission/memory/SdCardMountedIF.h"
+#include "mission/system/DualLanePowerStateMachine.h"
+#include "mission/system/definitions.h"
 
 #ifdef FSFW_OSAL_LINUX
 class SpiComIF;
@@ -60,7 +62,8 @@ class PayloadPcduHandler : public DeviceHandlerBase {
   static constexpr Event I_HPA_OUT_OF_BOUNDS = event::makeEvent(SUBSYSTEM_ID, 11, severity::MEDIUM);
 
   PayloadPcduHandler(object_id_t objectId, object_id_t comIF, CookieIF* cookie, GpioIF* gpioIF,
-                     SdCardMountedIF* sdcMan, bool periodicPrintout);
+                     SdCardMountedIF* sdcMan, PowerSwitchIF* pwrSwitcher, power::Switch_t switchCh0,
+                     power::Switch_t switchCh1, bool periodicPrintout);
 
   void setToGoToNormalModeImmediately(bool enable);
   void enablePeriodicPrintout(bool enable, uint8_t divider);
@@ -75,7 +78,8 @@ class PayloadPcduHandler : public DeviceHandlerBase {
 
  private:
   enum class States : uint8_t {
-    PCDU_OFF,
+    PL_PCDU_OFF,
+    POWER_CHANNELS_ON,
     // Solid State Relay, enable battery voltages VBAT0 and VBAT1. This will also switch on
     // the ADC
     ON_TRANS_SSR,
@@ -92,8 +96,10 @@ class PayloadPcduHandler : public DeviceHandlerBase {
     // Switch on HPA component and monitor voltages for 5 seconds
     ON_TRANS_HPA,
     // All components of the experiment are on
-    PCDU_ON,
+    PL_PCDU_ON,
-  } state = States::PCDU_OFF;
+  } state = States::PL_PCDU_OFF;
+
+  duallane::Submodes pwrSubmode = duallane::Submodes::A_SIDE;
 
   enum class AdcMode { EXT_CONV, INT_CONV } adcMode = AdcMode::INT_CONV;
 
@@ -127,17 +133,19 @@ class PayloadPcduHandler : public DeviceHandlerBase {
   GpioIF* gpioIF;
   SdCardMountedIF* sdcMan;
   plpcdu::PlPcduParameter params;
+  bool quickTransitionAlreadyCalled = true;
 
   PoolEntry<uint16_t> channelValues = PoolEntry<uint16_t>({0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
   PoolEntry<float> processedValues =
       PoolEntry<float>({0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0});
   PoolEntry<float> tempC = PoolEntry<float>({0.0});
+  DualLanePowerStateMachine pwrStateMachine;
 
   void doTransition(Mode_t modeFrom, Submode_t subModeFrom) override;
   void doStartUp() override;
   void doShutDown() override;
   // Main FDIR function which goes from any PL PCDU state back to all off
-  void transitionBackToOff(bool notifyFdir);
+  void quickTransitionBackToOff(bool startTransitionToOff, bool notifyFdir);
   ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t* id) override;
   ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t* id) override;
   void fillCommandAndReplyMap() override;
@@ -158,7 +166,7 @@ class PayloadPcduHandler : public DeviceHandlerBase {
   void checkAdcValues();
   void handleOutOfBoundsPrintout();
   void checkJsonFileInit();
-  void stateMachineToNormal();
+  ReturnValue_t stateMachineToNormal(Mode_t modeFrom, Submode_t subModeFrom);
   bool checkVoltage(float val, float lowerBound, float upperBound, Event event);
   bool checkCurrent(float val, float upperBound, Event event);
   void handleFailureInjection(std::string output, Event event);

mission/devices/devicedefinitions/payloadPcduDefinitions.h

@@ -91,8 +91,15 @@ static constexpr DeviceCommandId_t SETUP_CMD = 1;
 static constexpr DeviceCommandId_t READ_TEMP_EXT = 2;
 static constexpr DeviceCommandId_t READ_WITH_TEMP_EXT = 3;
 
-static constexpr Submode_t NORMAL_ADC_ONLY = 0;
+enum NormalSubmodes {
-static constexpr Submode_t NORMAL_ALL_ON = 1;
+  ALL_OFF = 0,
+  SOLID_STATE_RELAYS_ADC_ON = 1,
+  DRO_ON = 2,
+  X8_ON = 3,
+  TX_ON = 4,
+  MPA_ON = 5,
+  HPA_ON = 6
+};
 
 // 12 ADC values * 2 + trailing zero
 static constexpr size_t ADC_REPLY_SIZE = 25;

mission/system/DualLanePowerStateMachine.cpp

@@ -3,8 +3,8 @@
 #include <fsfw/devicehandlers/AssemblyBase.h>
 #include <fsfw/power/PowerSwitchIF.h>
 
-DualLanePowerStateMachine::DualLanePowerStateMachine(pcduSwitches::Switches switchA,
+DualLanePowerStateMachine::DualLanePowerStateMachine(power::Switch_t switchA,
-                                                     pcduSwitches::Switches switchB,
+                                                     power::Switch_t switchB,
                                                      PowerSwitchIF* pwrSwitcher,
                                                      dur_millis_t checkTimeout)
     : PowerStateMachineBase(pwrSwitcher, checkTimeout), SWITCH_A(switchA), SWITCH_B(switchB) {}

mission/system/DualLanePowerStateMachine.h

@@ -12,12 +12,12 @@ class PowerSwitchIF;
 
 class DualLanePowerStateMachine : public PowerStateMachineBase {
  public:
-  DualLanePowerStateMachine(pcduSwitches::Switches switchA, pcduSwitches::Switches switchB,
+  DualLanePowerStateMachine(power::Switch_t switchA, power::Switch_t switchB,
                             PowerSwitchIF* pwrSwitcher, dur_millis_t checkTimeout = 5000);
   power::OpCodes fsm() override;
 
-  const pcduSwitches::Switches SWITCH_A;
+  const power::Switch_t SWITCH_A;
-  const pcduSwitches::Switches SWITCH_B;
+  const power::Switch_t SWITCH_B;
 
  private:
 };

mission/system/PlPcduAssembly.cpp

@@ -1 +0,0 @@
-#include "PlPcduAssembly.h"

mission/system/PlPcduAssembly.h

@@ -1,4 +0,0 @@
-#ifndef MISSION_SYSTEM_PLPCDUASSEMBLY_H_
-#define MISSION_SYSTEM_PLPCDUASSEMBLY_H_
-
-#endif /* MISSION_SYSTEM_PLPCDUASSEMBLY_H_ */