CMakeLists.txt

@@ -16,14 +16,21 @@ set(CMAKE_SCRIPT_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 option(EIVE_BUILD_UNITTESTS "Build Catch2 unittests" OFF)
 option(EIVE_ADD_ETL_LIB "Add ETL library" ON)
 option(EIVE_ADD_JSON_LIB "Add JSON library" ON)
+
 option(EIVE_SYSROOT_MAGIC "Perform sysroot magic which might not be necessary" OFF)
+option(EIVE_CREATE_UNIQUE_OBSW_BIN "Append username to generated binary name" ON)
 
 if(NOT FSFW_OSAL)
 	set(FSFW_OSAL linux CACHE STRING "OS for the FSFW.")
 endif()
 
-if(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/beagleboneblack")
+if(TGT_BSP)
+    if(TGT_BSP MATCHES "arm/raspberrypi" OR TGT_BSP MATCHES "arm/beagleboneblack")
         option(LINUX_CROSS_COMPILE ON)
+        option(EIVE_BUILD_GPSD_GPS_HANDLER "Build GPSD dependent GPS Handler" OFF)
+    elseif(TGT_BSP MATCHES "arm/q7s")
+        option(EIVE_BUILD_GPSD_GPS_HANDLER "Build GPSD dependent GPS Handler" ON)
+    endif()
 endif()
 
 # Perform steps like loading toolchain files where applicable.
@@ -166,7 +173,7 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 		"-Wno-unused-parameter"
 		"-Wno-psabi"
 	)
-	message(STATUS "goes here")
+
 	# Remove unused sections.
 	add_compile_options(
 		"-ffunction-sections"
@@ -188,6 +195,12 @@ add_library(${LIB_EIVE_MISSION})
 
 # Add executable
 add_executable(${OBSW_NAME})
+if(EIVE_CREATE_UNIQUE_OBSW_BIN)
+    set(OBSW_BIN_NAME ${CMAKE_PROJECT_NAME}-$ENV{USERNAME})
+else()
+    set(OBSW_BIN_NAME ${CMAKE_PROJECT_NAME})
+endif()
+set_target_properties(${OBSW_NAME} PROPERTIES OUTPUT_NAME ${OBSW_BIN_NAME})
 
 #watchdog
 add_executable(${WATCHDOG_NAME} EXCLUDE_FROM_ALL)
@@ -346,9 +359,10 @@ string(CONCAT POST_BUILD_COMMENT
 add_custom_command(
    TARGET ${OBSW_NAME}
    POST_BUILD
-   COMMAND ${CMAKE_SIZE} ${OBSW_NAME}${FILE_SUFFIX}
+   COMMAND ${CMAKE_SIZE} ${OBSW_BIN_NAME}${FILE_SUFFIX}
    COMMENT ${POST_BUILD_COMMENT}
 )
 
+
 include (${CMAKE_SCRIPT_PATH}/BuildType.cmake)
 set_build_type()

README.md

@@ -175,7 +175,7 @@ To build the EIVE watchdog, the corresponding target must be specified in the bu
 The configure steps do not need to be repeated if the folder has already been configured.
 
 ```sh
-mkdir build-Debug-Q7S && cd build-Debug-Q7S
+mkdir build-Debug-Watchdog && cd build-Debug-Watchdog
 cmake -DTGT_BSP=arm/q7s -DCMAKE_BUILD_TYPE=Debug ..
 cmake --build . --target eive-watchdog -j
 ```

bsp_linux_board/CMakeLists.txt

@@ -1,4 +1,4 @@
-target_sources(${TARGET_NAME} PUBLIC
+target_sources(${OBSW_NAME} PUBLIC
 	InitMission.cpp
 	main.cpp
 	ObjectFactory.cpp

bsp_linux_board/InitMission.cpp

@@ -211,7 +211,7 @@ void initmission::createTestTasks(TaskFactory& factory,
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("TEST_TASK", objects::TEST_TASK);
   }
-#if RPI_ADD_SPI_TEST == 1
+#if OBSW_ADD_SPI_TEST_CODE == 1
   result = testTask->addComponent(objects::SPI_TEST);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("SPI_TEST", objects::SPI_TEST);
@@ -223,12 +223,13 @@ void initmission::createTestTasks(TaskFactory& factory,
     initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
   }
 #endif /* RPI_ADD_GPIO_TEST == 1 */
-#if RPI_ADD_UART_TEST == 1
+#if OBSW_ADD_UART_TEST_CODE == 1
   result = testTask->addComponent(objects::UART_TEST);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     initmission::printAddObjectError("UART_TEST", objects::UART_TEST);
   }
 #endif /* RPI_ADD_GPIO_TEST == 1 */
+  taskVec.push_back(testTask);
 
   bool startTestPst = true;
   static_cast<void>(startTestPst);

bsp_linux_board/ObjectFactory.cpp

@@ -1,9 +1,7 @@
 #include "ObjectFactory.h"
 
-#include <devConf.h>
-#include <mission/devices/GPSHyperionHandler.h>
-
 #include "OBSWConfig.h"
+#include "devConf.h"
 #include "devices/addresses.h"
 #include "devices/gpioIds.h"
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
@@ -15,6 +13,7 @@
 #include "linux/boardtest/SpiTestClass.h"
 #include "linux/boardtest/UartTestClass.h"
 #include "mission/core/GenericFactory.h"
+#include "mission/devices/GPSHyperionHandler.h"
 #include "mission/devices/GyroADIS1650XHandler.h"
 #include "mission/utility/TmFunnel.h"
 #include "objects/systemObjectList.h"
@@ -61,16 +60,6 @@ void ObjectFactory::produce(void* args) {
   Factory::setStaticFrameworkObjectIds();
   ObjectFactory::produceGenericObjects();
 
-#if OBSW_USE_TMTC_TCP_BRIDGE == 1
-  auto tmtcBridge = new TcpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
-  tmtcBridge->setMaxNumberOfPacketsStored(50);
-  new TcpTmTcServer(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
-#else
-  auto tmtcBridge = new UdpTmTcBridge(objects::TMTC_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR);
-  tmtcBridge->setMaxNumberOfPacketsStored(50);
-  new UdpTcPollingTask(objects::TMTC_POLLING_TASK, objects::TMTC_BRIDGE);
-#endif
-
   GpioIF* gpioIF = new LinuxLibgpioIF(objects::GPIO_IF);
   GpioCookie* gpioCookie = nullptr;
   static_cast<void>(gpioCookie);
@@ -188,11 +177,11 @@ void ObjectFactory::produce(void* args) {
 void ObjectFactory::createTestTasks() {
   new TestTask(objects::TEST_TASK);
 
-#if RPI_ADD_SPI_TEST == 1
+#if OBSW_ADD_SPI_TEST_CODE == 1
   new SpiTestClass(objects::SPI_TEST, gpioIF);
 #endif
 
-#if RPI_ADD_UART_TEST == 1
+#if OBSW_ADD_UART_TEST_CODE == 1
   new UartTestClass(objects::UART_TEST);
 #else
   new UartComIF(objects::UART_COM_IF);

bsp_linux_board/boardconfig/CMakeLists.txt

@@ -1,7 +1,7 @@
-target_sources(${TARGET_NAME} PRIVATE
+target_sources(${OBSW_NAME} PRIVATE
 	print.c
 )
 
-target_include_directories(${TARGET_NAME} PUBLIC
+target_include_directories(${OBSW_NAME} PUBLIC
 	${CMAKE_CURRENT_SOURCE_DIR}
 )

bsp_linux_board/boardtest/CMakeLists.txt

@@ -1,4 +1,4 @@
-target_sources(${TARGET_NAME} PRIVATE
+target_sources(${OBSW_NAME} PRIVATE
 )
 
 

bsp_q7s/CMakeLists.txt

@@ -11,19 +11,15 @@ target_link_libraries(${SIMPLE_OBSW_NAME} PUBLIC
 target_compile_definitions(${SIMPLE_OBSW_NAME} PRIVATE "Q7S_SIMPLE_MODE")
 add_subdirectory(simple)
 
-
 target_sources(${OBSW_NAME} PUBLIC
 	main.cpp
 )
 
 add_subdirectory(boardtest)
 
-
 add_subdirectory(boardconfig)
 add_subdirectory(comIF)
-add_subdirectory(gpio)
 add_subdirectory(core)
 add_subdirectory(memory)
 add_subdirectory(callbacks)
 add_subdirectory(devices)
-

bsp_q7s/boardconfig/busConf.h

@@ -29,6 +29,7 @@ static const int PTME_CONFIG = 4;
 }  // namespace uiomapids
 
 namespace gpioNames {
+
 static constexpr char GYRO_0_ADIS_CS[] = "gyro_0_adis_chip_select";
 static constexpr char GYRO_1_L3G_CS[] = "gyro_1_l3g_chip_select";
 static constexpr char GYRO_2_ADIS_CS[] = "gyro_2_adis_chip_select";
@@ -44,6 +45,8 @@ static constexpr char GNSS_1_ENABLE[] = "enable_gnss_1";
 static constexpr char GYRO_0_ENABLE[] = "enable_gyro_0";
 static constexpr char GYRO_2_ENABLE[] = "enable_gyro_2";
 static constexpr char GNSS_SELECT[] = "gnss_mux_select";
+static constexpr char GNSS_MUX_SELECT[] = "gnss_mux_select";
+
 static constexpr char HEATER_0[] = "heater0";
 static constexpr char HEATER_1[] = "heater1";
 static constexpr char HEATER_2[] = "heater2";
@@ -54,19 +57,20 @@ static constexpr char HEATER_6[] = "heater6";
 static constexpr char HEATER_7[] = "heater7";
 static constexpr char SA_DPL_PIN_0[] = "sa_dpl_0";
 static constexpr char SA_DPL_PIN_1[] = "sa_dpl_1";
+static constexpr char SPI_MUX_BIT_0_PIN[] = "spi_mux_bit_0";
 static constexpr char SPI_MUX_BIT_1_PIN[] = "spi_mux_bit_1";
 static constexpr char SPI_MUX_BIT_2_PIN[] = "spi_mux_bit_2";
 static constexpr char SPI_MUX_BIT_3_PIN[] = "spi_mux_bit_3";
 static constexpr char SPI_MUX_BIT_4_PIN[] = "spi_mux_bit_4";
 static constexpr char SPI_MUX_BIT_5_PIN[] = "spi_mux_bit_5";
-static constexpr char SPI_MUX_BIT_6_PIN[] = "spi_mux_bit_6";
 static constexpr char EN_RW_CS[] = "en_rw_cs";
 static constexpr char EN_RW_1[] = "enable_rw_1";
 static constexpr char EN_RW_2[] = "enable_rw_2";
 static constexpr char EN_RW_3[] = "enable_rw_3";
 static constexpr char EN_RW_4[] = "enable_rw_4";
-static constexpr char GNSS_MUX_SELECT[] = "gnss_mux_select";
+
 static constexpr char RAD_SENSOR_CHIP_SELECT[] = "rad_sensor_chip_select";
+static constexpr char ENABLE_RADFET[] = "enable_radfet";
 static constexpr char PAPB_BUSY_SIGNAL_VC0[] = "papb_busy_signal_vc0";
 static constexpr char PAPB_EMPTY_SIGNAL_VC0[] = "papb_empty_signal_vc0";
 static constexpr char PAPB_BUSY_SIGNAL_VC1[] = "papb_busy_signal_vc1";
@@ -80,6 +84,16 @@ static constexpr char RS485_EN_TX_DATA[] = "tx_data_enable_ltc2872";
 static constexpr char RS485_EN_RX_CLOCK[] = "rx_clock_enable_ltc2872";
 static constexpr char RS485_EN_RX_DATA[] = "rx_data_enable_ltc2872";
 static constexpr char PDEC_RESET[] = "pdec_reset";
+
+static constexpr char PL_PCDU_ENABLE_VBAT0[] = "enable_plpcdu_vbat0";
+static constexpr char PL_PCDU_ENABLE_VBAT1[] = "enable_plpcdu_vbat1";
+static constexpr char PL_PCDU_ENABLE_DRO[] = "enable_plpcdu_dro";
+static constexpr char PL_PCDU_ENABLE_X8[] = "enable_plpcdu_x8";
+static constexpr char PL_PCDU_ENABLE_TX[] = "enable_plpcdu_tx";
+static constexpr char PL_PCDU_ENABLE_HPA[] = "enable_plpcdu_hpa";
+static constexpr char PL_PCDU_ENABLE_MPA[] = "enable_plpcdu_mpa";
+static constexpr char PL_PCDU_ADC_CS[] = "plpcdu_adc_chip_select";
+
 }  // namespace gpioNames
 }  // namespace q7s
 

bsp_q7s/callbacks/CMakeLists.txt

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

bsp_q7s/callbacks/gpioCallbacks.cpp

@@ -25,38 +25,28 @@ void initSpiCsDecoder(GpioIF* gpioComIF) {
 
   GpiodRegularByLineName* spiMuxBit = nullptr;
   /** Setting mux bit 1 to low will disable IC21 on the interface board */
-  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_1_PIN, "SPI Mux Bit 1",
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_0_PIN, "SPI Mux Bit 1",
+                                         gpio::DIR_OUT, gpio::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",
                                          gpio::DIR_OUT, gpio::HIGH);
   spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_1, spiMuxBit);
-  /** Setting mux bit 2 to low disables IC1 on the TCS board */
-  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_2_PIN, "SPI Mux Bit 2",
-                                         gpio::DIR_OUT, gpio::HIGH);
-  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_2, 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_3_PIN, "SPI Mux Bit 3",
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_2_PIN, "SPI Mux Bit 3",
                                          gpio::DIR_OUT, gpio::LOW);
-  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_3, spiMuxBit);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_2, spiMuxBit);
-
-  //    spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_1_PIN, "SPI Mux Bit 1",
-  //            gpio::OUT, gpio::LOW);
-  //    spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_1, spiMuxBit);
-  //    /** Setting mux bit 2 to low disables IC1 on the TCS board */
-  //    spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_2_PIN, "SPI Mux Bit 2",
-  //    gpio::OUT, gpio::HIGH); spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_2, 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_3_PIN, "SPI Mux Bit
-  //    3", gpio::OUT, gpio::LOW); spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_3, spiMuxBit);
 
   /** The following gpios can take arbitrary initial values */
-  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_4_PIN, "SPI Mux Bit 4",
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_3_PIN, "SPI Mux Bit 4",
+                                         gpio::DIR_OUT, gpio::LOW);
+  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_3, spiMuxBit);
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_4_PIN, "SPI Mux Bit 5",
                                          gpio::DIR_OUT, gpio::LOW);
   spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_4, spiMuxBit);
-  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_5_PIN, "SPI Mux Bit 5",
+  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_5_PIN, "SPI Mux Bit 6",
                                          gpio::DIR_OUT, gpio::LOW);
   spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_5, spiMuxBit);
-  spiMuxBit = new GpiodRegularByLineName(q7s::gpioNames::SPI_MUX_BIT_6_PIN, "SPI Mux Bit 6",
-                                         gpio::DIR_OUT, gpio::LOW);
-  spiMuxGpios->addGpio(gpioIds::SPI_MUX_BIT_6, spiMuxBit);
   GpiodRegularByLineName* enRwDecoder =
       new GpiodRegularByLineName(q7s::gpioNames::EN_RW_CS, "EN_RW_CS", gpio::DIR_OUT, gpio::HIGH);
   spiMuxGpios->addGpio(gpioIds::EN_RW_CS, enRwDecoder);
@@ -147,6 +137,10 @@ void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Lev
         disableDecoderTcsIc2();
         break;
       }
+      case (gpioIds::CS_SUS_0): {
+        disableDecoderInterfaceBoardIc1();
+        break;
+      }
       case (gpioIds::CS_SUS_1): {
         disableDecoderInterfaceBoardIc1();
         break;
@@ -156,23 +150,23 @@ void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Lev
         break;
       }
       case (gpioIds::CS_SUS_3): {
-        disableDecoderInterfaceBoardIc2();
+        disableDecoderInterfaceBoardIc1();
         break;
       }
       case (gpioIds::CS_SUS_4): {
-        disableDecoderInterfaceBoardIc2();
+        disableDecoderInterfaceBoardIc1();
         break;
       }
       case (gpioIds::CS_SUS_5): {
-        disableDecoderInterfaceBoardIc2();
+        disableDecoderInterfaceBoardIc1();
         break;
       }
       case (gpioIds::CS_SUS_6): {
-        disableDecoderInterfaceBoardIc1();
+        disableDecoderInterfaceBoardIc2();
         break;
       }
       case (gpioIds::CS_SUS_7): {
-        disableDecoderInterfaceBoardIc1();
+        disableDecoderInterfaceBoardIc2();
         break;
       }
       case (gpioIds::CS_SUS_8): {
@@ -180,25 +174,17 @@ void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Lev
         break;
       }
       case (gpioIds::CS_SUS_9): {
-        disableDecoderInterfaceBoardIc1();
+        disableDecoderInterfaceBoardIc2();
         break;
       }
       case (gpioIds::CS_SUS_10): {
-        disableDecoderInterfaceBoardIc1();
+        disableDecoderInterfaceBoardIc2();
         break;
       }
       case (gpioIds::CS_SUS_11): {
         disableDecoderInterfaceBoardIc2();
         break;
       }
-      case (gpioIds::CS_SUS_12): {
-        disableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_13): {
-        disableDecoderInterfaceBoardIc1();
-        break;
-      }
       case (gpioIds::CS_RW1): {
         disableRwDecoder();
         break;
@@ -300,71 +286,66 @@ void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Lev
         enableDecoderTcsIc2();
         break;
       }
-      case (gpioIds::CS_SUS_1): {
+      case (gpioIds::CS_SUS_0): {
         selectY0();
         enableDecoderInterfaceBoardIc1();
         break;
       }
+      case (gpioIds::CS_SUS_1): {
+        selectY1();
+        enableDecoderInterfaceBoardIc1();
+        break;
+      }
       case (gpioIds::CS_SUS_2): {
-        selectY1();
+        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_4): {
+      case (gpioIds::CS_SUS_7): {
         selectY1();
         enableDecoderInterfaceBoardIc2();
         break;
       }
-      case (gpioIds::CS_SUS_5): {
-        selectY2();
-        enableDecoderInterfaceBoardIc2();
-        break;
-      }
-      case (gpioIds::CS_SUS_6): {
-        selectY2();
-        enableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_7): {
-        selectY3();
-        enableDecoderInterfaceBoardIc1();
-        break;
-      }
       case (gpioIds::CS_SUS_8): {
-        selectY3();
+        selectY2();
         enableDecoderInterfaceBoardIc2();
         break;
       }
       case (gpioIds::CS_SUS_9): {
-        selectY4();
+        selectY3();
-        enableDecoderInterfaceBoardIc1();
+        enableDecoderInterfaceBoardIc2();
         break;
       }
       case (gpioIds::CS_SUS_10): {
-        selectY5();
-        enableDecoderInterfaceBoardIc1();
-        break;
-      }
-      case (gpioIds::CS_SUS_11): {
         selectY4();
         enableDecoderInterfaceBoardIc2();
         break;
       }
-      case (gpioIds::CS_SUS_12): {
+      case (gpioIds::CS_SUS_11): {
         selectY5();
         enableDecoderInterfaceBoardIc2();
         break;
       }
-      case (gpioIds::CS_SUS_13): {
-        selectY6();
-        enableDecoderInterfaceBoardIc1();
-        break;
-      }
       case (gpioIds::CS_RW1): {
         selectY0();
         enableRwDecoder();
@@ -394,52 +375,52 @@ void spiCsDecoderCallback(gpioId_t gpioId, gpio::GpioOperation gpioOp, gpio::Lev
 }
 
 void enableDecoderTcsIc1() {
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_0);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
 }
 
 void enableDecoderTcsIc2() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
+  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 enableDecoderInterfaceBoardIc1() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
-}
-
-void enableDecoderInterfaceBoardIc2() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-}
-
 void disableDecoderTcsIc1() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
   gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
 }
 
 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);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
 }
 
 void disableDecoderInterfaceBoardIc1() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
   gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
 }
 
 void disableDecoderInterfaceBoardIc2() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_0);
   gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_1);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_2);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_2);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
 }
 
 void enableRwDecoder() { gpioComInterface->pullHigh(gpioIds::EN_RW_CS); }
@@ -447,57 +428,57 @@ 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);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_6);
 }
 
 void selectY1() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
   gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_6);
 }
 
 void selectY2() {
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_6);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
 }
 
 void selectY3() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
   gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_6);
 }
 
 void selectY4() {
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
   gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_6);
 }
 
 void selectY5() {
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_5);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_6);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
 }
 
 void selectY6() {
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_4);
+  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
   gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_6);
 }
 
 void selectY7() {
+  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_3);
   gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_4);
   gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_5);
-  gpioComInterface->pullHigh(gpioIds::SPI_MUX_BIT_6);
 }
 
 void disableAllDecoder() {
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_3);
-  gpioComInterface->pullLow(gpioIds::SPI_MUX_BIT_1);
   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);
 }
 

bsp_q7s/core/ObjectFactory.cpp

@@ -1,20 +1,21 @@
 #include "ObjectFactory.h"
 
-#include <linux/boardtest/I2cTestClass.h>
+#include <linux/obc/AxiPtmeConfig.h>
-#include <linux/boardtest/UartTestClass.h>
+#include <linux/obc/PapbVcInterface.h>
-
+#include <linux/obc/PdecHandler.h>
-#include <sstream>
+#include <linux/obc/Ptme.h>
+#include <linux/obc/PtmeConfig.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/rwSpiCallback.h"
 #include "bsp_q7s/core/CoreController.h"
 #include "bsp_q7s/devices/PlocMemoryDumper.h"
 #include "bsp_q7s/devices/PlocSupervisorHandler.h"
 #include "bsp_q7s/devices/PlocUpdater.h"
-#include "bsp_q7s/gpio/gpioCallbacks.h"
 #include "bsp_q7s/memory/FileSystemHandler.h"
 #include "busConf.h"
 #include "ccsdsConfig.h"
@@ -22,6 +23,19 @@
 #include "devices/addresses.h"
 #include "devices/gpioIds.h"
 #include "devices/powerSwitcherList.h"
+#include "linux/boardtest/I2cTestClass.h"
+#include "linux/boardtest/SpiTestClass.h"
+#include "linux/boardtest/UartTestClass.h"
+#include "linux/csp/CspComIF.h"
+#include "linux/csp/CspCookie.h"
+#include "tmtc/apid.h"
+#include "tmtc/pusIds.h"
+#if OBSW_TEST_LIBGPIOD == 1
+#include "linux/boardtest/LibgpiodTest.h"
+#endif
+
+#include <sstream>
+
 #include "fsfw/datapoollocal/LocalDataPoolManager.h"
 #include "fsfw/tmtcpacket/pus/tm.h"
 #include "fsfw/tmtcservices/CommandingServiceBase.h"
@@ -40,16 +54,16 @@
 #include "linux/boardtest/SpiTestClass.h"
 #include "linux/csp/CspComIF.h"
 #include "linux/csp/CspCookie.h"
-#include "linux/devices/SolarArrayDeploymentHandler.h"
-#include "linux/devices/SusHandler.h"
 #include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
-#include "linux/devices/devicedefinitions/SusDefinitions.h"
 #include "linux/devices/startracker/StarTrackerHandler.h"
 #include "linux/devices/startracker/StrHelper.h"
+#include "mission/devices/SolarArrayDeploymentHandler.h"
+#include "mission/devices/SusHandler.h"
+#include "mission/devices/devicedefinitions/SusDefinitions.h"
 #include "mission/core/GenericFactory.h"
 #include "mission/devices/ACUHandler.h"
 #include "mission/devices/BpxBatteryHandler.h"
-#include "mission/devices/GPSHyperionLinuxController.h"
+#include "linux/devices/GPSHyperionLinuxController.h"
 #include "mission/devices/GyroADIS1650XHandler.h"
 #include "mission/devices/HeaterHandler.h"
 #include "mission/devices/IMTQHandler.h"
@@ -61,6 +75,7 @@
 #include "mission/devices/PlocMPSoCHandler.h"
 #include "mission/devices/RadiationSensorHandler.h"
 #include "mission/devices/RwHandler.h"
+#include "mission/devices/SusHandler.h"
 #include "mission/devices/SyrlinksHkHandler.h"
 #include "mission/devices/Tmp1075Handler.h"
 #include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
@@ -68,22 +83,11 @@
 #include "mission/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #include "mission/devices/devicedefinitions/RadSensorDefinitions.h"
 #include "mission/devices/devicedefinitions/RwDefinitions.h"
+#include "mission/devices/devicedefinitions/SusDefinitions.h"
 #include "mission/devices/devicedefinitions/SyrlinksDefinitions.h"
 #include "mission/tmtc/CCSDSHandler.h"
 #include "mission/tmtc/VirtualChannel.h"
 #include "mission/utility/TmFunnel.h"
-#include "tmtc/apid.h"
-#include "tmtc/pusIds.h"
-
-#if OBSW_TEST_LIBGPIOD == 1
-#include "linux/boardtest/LibgpiodTest.h"
-#endif
-
-#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>
 
 ResetArgs resetArgsGnss0;
 ResetArgs resetArgsGnss1;
@@ -127,6 +131,7 @@ void ObjectFactory::produce(void* args) {
 #if BOARD_TE0720 == 0
   new CoreController(objects::CORE_CONTROLLER);
 
+  gpioCallbacks::disableAllDecoder();
   createPcduComponents(gpioComIF);
   createRadSensorComponent(gpioComIF);
   createSunSensorComponents(gpioComIF, spiComIF);
@@ -137,13 +142,11 @@ void ObjectFactory::produce(void* args) {
 
   createHeaterComponents();
   createSolarArrayDeploymentComponents();
+  createPlPcduComponents(gpioComIF, spiComIF);
 #if OBSW_ADD_SYRLINKS == 1
   createSyrlinksComponents();
 #endif /* OBSW_ADD_SYRLINKS == 1 */
-
-#if OBSW_ADD_RTD_DEVICES == 1
   createRtdComponents(gpioComIF);
-#endif /* OBSW_ADD_RTD_DEVICES == 1 */
 
 #if OBSW_ADD_MGT == 1
   I2cCookie* imtqI2cCookie =
@@ -251,9 +254,7 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, Ua
   new CspComIF(objects::CSP_COM_IF);
   *i2cComIF = new I2cComIF(objects::I2C_COM_IF);
   *uartComIF = new UartComIF(objects::UART_COM_IF);
-#if OBSW_ADD_SPI_TEST_CODE == 0
   *spiComIF = new SpiComIF(objects::SPI_COM_IF, *gpioComIF);
-#endif /* Q7S_ADD_SPI_TEST_CODE == 0 */
 
 #if BOARD_TE0720 == 0
   /* Adding gpios for chip select decoding to the gpioComIf */
@@ -295,18 +296,30 @@ void ObjectFactory::createRadSensorComponent(LinuxLibgpioIF* gpioComIF) {
   GpiodRegularByLineName* gpio = new GpiodRegularByLineName(
       q7s::gpioNames::RAD_SENSOR_CHIP_SELECT, consumer.str(), gpio::DIR_OUT, gpio::HIGH);
   gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, gpio);
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_RADFET, consumer.str(), gpio::DIR_OUT,
+                                    gpio::LOW);
+  gpioCookieRadSensor->addGpio(gpioIds::ENABLE_RADFET, gpio);
   gpioComIF->addGpios(gpioCookieRadSensor);
 
   SpiCookie* spiCookieRadSensor = new SpiCookie(
       addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, std::string(q7s::SPI_DEFAULT_DEV),
       RAD_SENSOR::READ_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
-  new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_COM_IF, spiCookieRadSensor);
+  auto radSensor = new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_COM_IF,
+                                              spiCookieRadSensor, gpioComIF);
+  static_cast<void>(radSensor);
+#if OBSW_TEST_RAD_SENSOR == 1
+  radSensor->setStartUpImmediately();
+  radSensor->setToGoToNormalModeImmediately();
+#endif
 }
 
 void ObjectFactory::createSunSensorComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF) {
   GpioCookie* gpioCookieSus = new GpioCookie();
   GpioCallback* susgpio = nullptr;
 
+  susgpio = new GpioCallback("Chip select SUS 0", gpio::DIR_OUT, gpio::HIGH,
+                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_0, susgpio);
   susgpio = new GpioCallback("Chip select SUS 1", gpio::DIR_OUT, gpio::HIGH,
                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
   gpioCookieSus->addGpio(gpioIds::CS_SUS_1, susgpio);
@@ -340,72 +353,124 @@ void ObjectFactory::createSunSensorComponents(LinuxLibgpioIF* gpioComIF, SpiComI
   susgpio = new GpioCallback("Chip select SUS 11", gpio::DIR_OUT, gpio::HIGH,
                              &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
   gpioCookieSus->addGpio(gpioIds::CS_SUS_11, susgpio);
-  susgpio = new GpioCallback("Chip select SUS 12", gpio::DIR_OUT, gpio::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_12, susgpio);
-  susgpio = new GpioCallback("Chip select SUS 13", gpio::DIR_OUT, gpio::HIGH,
-                             &gpioCallbacks::spiCsDecoderCallback, gpioComIF);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_13, susgpio);
 
   gpioComIF->addGpios(gpioCookieSus);
 
-  SpiCookie* spiCookieSus1 =
+#if OBSW_ADD_SUN_SENSORS == 1
-      new SpiCookie(addresses::SUS_1, gpio::NO_GPIO, std::string(q7s::SPI_DEFAULT_DEV),
+  SpiCookie* spiCookie =
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, SUS::MAX1227_SPI_FREQ);
+      new SpiCookie(addresses::SUS_0, gpioIds::CS_SUS_0, q7s::SPI_DEFAULT_DEV, SUS::MAX_CMD_SIZE,
-  SpiCookie* spiCookieSus2 =
+                    spi::DEFAULT_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-      new SpiCookie(addresses::SUS_2, gpio::NO_GPIO, std::string(q7s::SPI_DEFAULT_DEV),
+  SusHandler* susHandler0 = new SusHandler(objects::SUS_0, 0, objects::SPI_COM_IF, spiCookie);
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, SUS::MAX1227_SPI_FREQ);
-  SpiCookie* spiCookieSus3 =
-      new SpiCookie(addresses::SUS_3, gpio::NO_GPIO, std::string(q7s::SPI_DEFAULT_DEV),
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, SUS::MAX1227_SPI_FREQ);
-  SpiCookie* spiCookieSus4 =
-      new SpiCookie(addresses::SUS_4, gpio::NO_GPIO, std::string(q7s::SPI_DEFAULT_DEV),
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, SUS::MAX1227_SPI_FREQ);
-  SpiCookie* spiCookieSus5 =
-      new SpiCookie(addresses::SUS_5, gpio::NO_GPIO, std::string(q7s::SPI_DEFAULT_DEV),
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, SUS::MAX1227_SPI_FREQ);
-  SpiCookie* spiCookieSus6 =
-      new SpiCookie(addresses::SUS_6, gpio::NO_GPIO, std::string(q7s::SPI_DEFAULT_DEV),
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, SUS::MAX1227_SPI_FREQ);
-  SpiCookie* spiCookieSus7 =
-      new SpiCookie(addresses::SUS_7, gpio::NO_GPIO, std::string(q7s::SPI_DEFAULT_DEV),
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, SUS::MAX1227_SPI_FREQ);
-  SpiCookie* spiCookieSus8 =
-      new SpiCookie(addresses::SUS_8, gpio::NO_GPIO, std::string(q7s::SPI_DEFAULT_DEV),
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, SUS::MAX1227_SPI_FREQ);
-  SpiCookie* spiCookieSus9 =
-      new SpiCookie(addresses::SUS_9, gpio::NO_GPIO, std::string(q7s::SPI_DEFAULT_DEV),
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, SUS::MAX1227_SPI_FREQ);
-  SpiCookie* spiCookieSus10 =
-      new SpiCookie(addresses::SUS_10, gpio::NO_GPIO, std::string(q7s::SPI_DEFAULT_DEV),
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, SUS::MAX1227_SPI_FREQ);
-  SpiCookie* spiCookieSus11 =
-      new SpiCookie(addresses::SUS_11, gpio::NO_GPIO, std::string(q7s::SPI_DEFAULT_DEV),
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, SUS::MAX1227_SPI_FREQ);
-  SpiCookie* spiCookieSus12 =
-      new SpiCookie(addresses::SUS_12, gpio::NO_GPIO, std::string(q7s::SPI_DEFAULT_DEV),
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, SUS::MAX1227_SPI_FREQ);
-  SpiCookie* spiCookieSus13 =
-      new SpiCookie(addresses::SUS_13, gpio::NO_GPIO, std::string(q7s::SPI_DEFAULT_DEV),
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, SUS::MAX1227_SPI_FREQ);
 
-  new SusHandler(objects::SUS_1, objects::SPI_COM_IF, spiCookieSus1, gpioComIF, gpioIds::CS_SUS_1);
+  spiCookie =
-  new SusHandler(objects::SUS_2, objects::SPI_COM_IF, spiCookieSus2, gpioComIF, gpioIds::CS_SUS_2);
+      new SpiCookie(addresses::SUS_1, gpioIds::CS_SUS_1, q7s::SPI_DEFAULT_DEV, SUS::MAX_CMD_SIZE,
-  new SusHandler(objects::SUS_3, objects::SPI_COM_IF, spiCookieSus3, gpioComIF, gpioIds::CS_SUS_3);
+                    spi::DEFAULT_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  new SusHandler(objects::SUS_4, objects::SPI_COM_IF, spiCookieSus4, gpioComIF, gpioIds::CS_SUS_4);
+  SusHandler* susHandler1 = new SusHandler(objects::SUS_1, 1, objects::SPI_COM_IF, spiCookie);
-  new SusHandler(objects::SUS_5, objects::SPI_COM_IF, spiCookieSus5, gpioComIF, gpioIds::CS_SUS_5);
+
-  new SusHandler(objects::SUS_6, objects::SPI_COM_IF, spiCookieSus6, gpioComIF, gpioIds::CS_SUS_6);
+  spiCookie =
-  new SusHandler(objects::SUS_7, objects::SPI_COM_IF, spiCookieSus7, gpioComIF, gpioIds::CS_SUS_7);
+      new SpiCookie(addresses::SUS_2, gpioIds::CS_SUS_2, q7s::SPI_DEFAULT_DEV, SUS::MAX_CMD_SIZE,
-  new SusHandler(objects::SUS_8, objects::SPI_COM_IF, spiCookieSus8, gpioComIF, gpioIds::CS_SUS_8);
+                    spi::DEFAULT_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  new SusHandler(objects::SUS_9, objects::SPI_COM_IF, spiCookieSus9, gpioComIF, gpioIds::CS_SUS_9);
+  SusHandler* susHandler2 = new SusHandler(objects::SUS_2, 2, objects::SPI_COM_IF, spiCookie);
-  new SusHandler(objects::SUS_10, objects::SPI_COM_IF, spiCookieSus10, gpioComIF,
+
-                 gpioIds::CS_SUS_10);
+  spiCookie =
-  new SusHandler(objects::SUS_11, objects::SPI_COM_IF, spiCookieSus11, gpioComIF,
+      new SpiCookie(addresses::SUS_3, gpioIds::CS_SUS_3, std::string(q7s::SPI_DEFAULT_DEV),
-                 gpioIds::CS_SUS_11);
+                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
-  new SusHandler(objects::SUS_12, objects::SPI_COM_IF, spiCookieSus12, gpioComIF,
+  SusHandler* susHandler3 = new SusHandler(objects::SUS_3, 3, objects::SPI_COM_IF, spiCookie);
-                 gpioIds::CS_SUS_12);
+
-  new SusHandler(objects::SUS_13, objects::SPI_COM_IF, spiCookieSus13, gpioComIF,
+  spiCookie =
-                 gpioIds::CS_SUS_13);
+      new SpiCookie(addresses::SUS_4, gpioIds::CS_SUS_4, std::string(q7s::SPI_DEFAULT_DEV),
+                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  SusHandler* susHandler4 = new SusHandler(objects::SUS_4, 4, objects::SPI_COM_IF, spiCookie);
+
+  spiCookie =
+      new SpiCookie(addresses::SUS_5, gpioIds::CS_SUS_5, std::string(q7s::SPI_DEFAULT_DEV),
+                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  SusHandler* susHandler5 = new SusHandler(objects::SUS_5, 5, objects::SPI_COM_IF, spiCookie);
+
+  spiCookie =
+      new SpiCookie(addresses::SUS_6, gpioIds::CS_SUS_6, q7s::SPI_DEFAULT_DEV, SUS::MAX_CMD_SIZE,
+                    spi::DEFAULT_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  SusHandler* susHandler6 = new SusHandler(objects::SUS_6, 6, objects::SPI_COM_IF, spiCookie,
+                                           gpioComIF, gpioIds::CS_SUS_6);
+
+  spiCookie =
+      new SpiCookie(addresses::SUS_7, gpioIds::CS_SUS_7, q7s::SPI_DEFAULT_DEV, SUS::MAX_CMD_SIZE,
+                    spi::DEFAULT_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  SusHandler* susHandler7 = new SusHandler(objects::SUS_7, 7, objects::SPI_COM_IF, spiCookie);
+
+  spiCookie =
+      new SpiCookie(addresses::SUS_8, gpioIds::CS_SUS_8, q7s::SPI_DEFAULT_DEV, SUS::MAX_CMD_SIZE,
+                    spi::DEFAULT_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  SusHandler* susHandler8 = new SusHandler(objects::SUS_8, 8, objects::SPI_COM_IF, spiCookie);
+
+  spiCookie =
+      new SpiCookie(addresses::SUS_9, gpioIds::CS_SUS_9, q7s::SPI_DEFAULT_DEV, SUS::MAX_CMD_SIZE,
+                    spi::DEFAULT_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  SusHandler* susHandler9 = new SusHandler(objects::SUS_9, 9, objects::SPI_COM_IF, spiCookie);
+
+  spiCookie =
+      new SpiCookie(addresses::SUS_10, gpioIds::CS_SUS_10, q7s::SPI_DEFAULT_DEV, SUS::MAX_CMD_SIZE,
+                    spi::DEFAULT_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  SusHandler* susHandler10 = new SusHandler(objects::SUS_10, 10, objects::SPI_COM_IF, spiCookie);
+
+  spiCookie =
+      new SpiCookie(addresses::SUS_11, gpioIds::CS_SUS_11, q7s::SPI_DEFAULT_DEV, SUS::MAX_CMD_SIZE,
+                    spi::DEFAULT_MAX_1227_MODE, spi::SUS_MAX1227_SPI_FREQ);
+  SusHandler* susHandler11 = new SusHandler(objects::SUS_11, 11, objects::SPI_COM_IF, spiCookie);
+  static_cast<void>(susHandler0);
+  static_cast<void>(susHandler1);
+  static_cast<void>(susHandler2);
+  static_cast<void>(susHandler3);
+  static_cast<void>(susHandler4);
+  static_cast<void>(susHandler5);
+  static_cast<void>(susHandler6);
+  static_cast<void>(susHandler7);
+  static_cast<void>(susHandler8);
+  static_cast<void>(susHandler9);
+  static_cast<void>(susHandler10);
+  static_cast<void>(susHandler11);
+#if OBSW_TEST_SUS == 1
+  susHandler0->setStartUpImmediately();
+  susHandler1->setStartUpImmediately();
+  susHandler2->setStartUpImmediately();
+  susHandler3->setStartUpImmediately();
+  susHandler4->setStartUpImmediately();
+  susHandler5->setStartUpImmediately();
+  susHandler6->setStartUpImmediately();
+  susHandler7->setStartUpImmediately();
+  susHandler8->setStartUpImmediately();
+  susHandler9->setStartUpImmediately();
+  susHandler10->setStartUpImmediately();
+  susHandler11->setStartUpImmediately();
+  susHandler0->setToGoToNormalMode(true);
+  susHandler1->setToGoToNormalMode(true);
+  susHandler2->setToGoToNormalMode(true);
+  susHandler3->setToGoToNormalMode(true);
+  susHandler4->setToGoToNormalMode(true);
+  susHandler5->setToGoToNormalMode(true);
+  susHandler6->setToGoToNormalMode(true);
+  susHandler7->setToGoToNormalMode(true);
+  susHandler8->setToGoToNormalMode(true);
+  susHandler9->setToGoToNormalMode(true);
+  susHandler10->setToGoToNormalMode(true);
+  susHandler11->setToGoToNormalMode(true);
+#if OBSW_DEBUG_SUS == 1
+  susHandler0->enablePeriodicPrintout(true, 3);
+  susHandler1->enablePeriodicPrintout(true, 3);
+  susHandler2->enablePeriodicPrintout(true, 3);
+  susHandler3->enablePeriodicPrintout(true, 3);
+  susHandler4->enablePeriodicPrintout(true, 3);
+  susHandler5->enablePeriodicPrintout(true, 3);
+  susHandler6->enablePeriodicPrintout(true, 3);
+  susHandler7->enablePeriodicPrintout(true, 3);
+  susHandler8->enablePeriodicPrintout(true, 3);
+  susHandler9->enablePeriodicPrintout(true, 3);
+  susHandler10->enablePeriodicPrintout(true, 3);
+  susHandler11->enablePeriodicPrintout(true, 3);
+#endif
+#endif
+
+#endif /* OBSW_ADD_SUN_SENSORS == 1 */
 }
 
 void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComIF* uartComIF) {
@@ -514,9 +579,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
                     MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
   auto mgmLis3Handler = new MgmLIS3MDLHandler(objects::MGM_0_LIS3_HANDLER, objects::SPI_COM_IF,
                                               spiCookie, spi::LIS3_TRANSITION_DELAY);
+#if OBSW_TEST_ACS == 1
   mgmLis3Handler->setStartUpImmediately();
-#if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
   mgmLis3Handler->setToGoToNormalMode(true);
+#if OBSW_DEBUG_ACS == 1
+  mgmLis3Handler->enablePeriodicPrintouts(true, 10);
+#endif
 #endif
 
   spiCookie =
@@ -524,9 +592,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
                     RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
   auto mgmRm3100Handler = new MgmRM3100Handler(objects::MGM_1_RM3100_HANDLER, objects::SPI_COM_IF,
                                                spiCookie, spi::RM3100_TRANSITION_DELAY);
+#if OBSW_TEST_ACS == 1
   mgmRm3100Handler->setStartUpImmediately();
-#if FSFW_HAL_RM3100_MGM_DEBUG == 1
   mgmRm3100Handler->setToGoToNormalMode(true);
+#if OBSW_DEBUG_ACS == 1
+  mgmRm3100Handler->enablePeriodicPrintouts(true, 10);
+#endif
 #endif
 
   spiCookie =
@@ -534,9 +605,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
                     MGMLIS3MDL::MAX_BUFFER_SIZE, spi::DEFAULT_LIS3_MODE, spi::DEFAULT_LIS3_SPEED);
   auto mgmLis3Handler2 = new MgmLIS3MDLHandler(objects::MGM_2_LIS3_HANDLER, objects::SPI_COM_IF,
                                                spiCookie, spi::LIS3_TRANSITION_DELAY);
+#if OBSW_TEST_ACS == 1
   mgmLis3Handler2->setStartUpImmediately();
-#if FSFW_HAL_LIS3MDL_MGM_DEBUG == 1
   mgmLis3Handler2->setToGoToNormalMode(true);
+#if OBSW_DEBUG_ACS == 1
+  mgmLis3Handler2->enablePeriodicPrintouts(true, 10);
+#endif
 #endif
 
   spiCookie =
@@ -544,9 +618,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
                     RM3100::MAX_BUFFER_SIZE, spi::DEFAULT_RM3100_MODE, spi::DEFAULT_RM3100_SPEED);
   mgmRm3100Handler = new MgmRM3100Handler(objects::MGM_3_RM3100_HANDLER, objects::SPI_COM_IF,
                                           spiCookie, spi::RM3100_TRANSITION_DELAY);
+#if OBSW_TEST_ACS == 1
   mgmRm3100Handler->setStartUpImmediately();
-#if FSFW_HAL_RM3100_MGM_DEBUG == 1
   mgmRm3100Handler->setToGoToNormalMode(true);
+#if OBSW_DEBUG_ACS == 1
+  mgmRm3100Handler->enablePeriodicPrintouts(true, 10);
+#endif
 #endif
 
   // Commented until ACS board V2 in in clean room again
@@ -556,9 +633,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
                             spi::DEFAULT_ADIS16507_SPEED);
   auto adisHandler = new GyroADIS1650XHandler(objects::GYRO_0_ADIS_HANDLER, objects::SPI_COM_IF,
                                               spiCookie, ADIS1650X::Type::ADIS16505);
+#if OBSW_TEST_ACS == 1
   adisHandler->setStartUpImmediately();
-#if FSFW_HAL_ADIS1650X_GYRO_DEBUG == 1
   adisHandler->setToGoToNormalModeImmediately();
+#if OBSW_DEBUG_ACS == 1
+  adisHandler->enablePeriodicPrintouts(true, 10);
+#endif
 #endif
 
   // Gyro 1 Side A
@@ -567,9 +647,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
                     spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
   auto gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_1_L3G_HANDLER, objects::SPI_COM_IF,
                                                spiCookie, spi::L3G_TRANSITION_DELAY);
+#if OBSW_TEST_ACS == 1
   gyroL3gHandler->setStartUpImmediately();
-#if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
   gyroL3gHandler->setToGoToNormalMode(true);
+#if OBSW_DEBUG_ACS == 1
+  gyroL3gHandler->enablePeriodicPrintouts(true, 10);
+#endif
 #endif
   // Gyro 2 Side B
   spiCookie = new SpiCookie(addresses::GYRO_2_ADIS, gpioIds::GYRO_2_ADIS_CS, spiDev,
@@ -577,8 +660,8 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
                             spi::DEFAULT_ADIS16507_SPEED);
   adisHandler = new GyroADIS1650XHandler(objects::GYRO_2_ADIS_HANDLER, objects::SPI_COM_IF,
                                          spiCookie, ADIS1650X::Type::ADIS16505);
+#if OBSW_TEST_ACS == 1
   adisHandler->setStartUpImmediately();
-#if FSFW_HAL_ADIS1650X_GYRO_DEBUG == 1
   adisHandler->setToGoToNormalModeImmediately();
 #endif
   // Gyro 3 Side B
@@ -587,9 +670,12 @@ void ObjectFactory::createAcsBoardComponents(LinuxLibgpioIF* gpioComIF, UartComI
                     spi::DEFAULT_L3G_MODE, spi::DEFAULT_L3G_SPEED);
   gyroL3gHandler = new GyroHandlerL3GD20H(objects::GYRO_3_L3G_HANDLER, objects::SPI_COM_IF,
                                           spiCookie, spi::L3G_TRANSITION_DELAY);
+#if OBSW_TEST_ACS == 1
   gyroL3gHandler->setStartUpImmediately();
-#if FSFW_HAL_L3GD20_GYRO_DEBUG == 1
   gyroL3gHandler->setToGoToNormalMode(true);
+#if OBSW_DEBUG_ACS == 1
+  gyroL3gHandler->enablePeriodicPrintouts(true, 10);
+#endif
 #endif
 
   bool debugGps = false;
@@ -735,6 +821,7 @@ void ObjectFactory::createRtdComponents(LinuxLibgpioIF* gpioComIF) {
 
   gpioComIF->addGpios(rtdGpioCookie);
 
+#if OBSW_ADD_RTD_DEVICES == 1
   SpiCookie* spiRtdIc0 =
       new SpiCookie(addresses::RTD_IC_3, gpioIds::RTD_IC_3, q7s::SPI_DEFAULT_DEV,
                     Max31865Definitions::MAX_REPLY_SIZE, spi::RTD_MODE, spi::RTD_SPEED);
@@ -817,13 +904,40 @@ void ObjectFactory::createRtdComponents(LinuxLibgpioIF* gpioComIF) {
   Max31865PT1000Handler* rtdIc15 =
       new Max31865PT1000Handler(objects::RTD_IC_18, objects::SPI_COM_IF, spiRtdIc15);
 
+#if OBSW_TEST_RTD == 1
   rtdIc0->setStartUpImmediately();
   rtdIc1->setStartUpImmediately();
   rtdIc2->setStartUpImmediately();
-#if OBSW_DEBUG_RTD == 1
+  rtdIc3->setStartUpImmediately();
+  rtdIc4->setStartUpImmediately();
+  rtdIc5->setStartUpImmediately();
+  rtdIc6->setStartUpImmediately();
+  rtdIc7->setStartUpImmediately();
+  rtdIc8->setStartUpImmediately();
+  rtdIc9->setStartUpImmediately();
+  rtdIc10->setStartUpImmediately();
+  rtdIc11->setStartUpImmediately();
+  rtdIc12->setStartUpImmediately();
+  rtdIc13->setStartUpImmediately();
+  rtdIc14->setStartUpImmediately();
+  rtdIc15->setStartUpImmediately();
+
   rtdIc0->setInstantNormal(true);
   rtdIc1->setInstantNormal(true);
   rtdIc2->setInstantNormal(true);
+  rtdIc3->setInstantNormal(true);
+  rtdIc4->setInstantNormal(true);
+  rtdIc5->setInstantNormal(true);
+  rtdIc6->setInstantNormal(true);
+  rtdIc7->setInstantNormal(true);
+  rtdIc8->setInstantNormal(true);
+  rtdIc9->setInstantNormal(true);
+  rtdIc10->setInstantNormal(true);
+  rtdIc11->setInstantNormal(true);
+  rtdIc12->setInstantNormal(true);
+  rtdIc13->setInstantNormal(true);
+  rtdIc14->setInstantNormal(true);
+  rtdIc15->setInstantNormal(true);
 #endif
 
   static_cast<void>(rtdIc0);
@@ -842,6 +956,7 @@ void ObjectFactory::createRtdComponents(LinuxLibgpioIF* gpioComIF) {
   static_cast<void>(rtdIc13);
   static_cast<void>(rtdIc14);
   static_cast<void>(rtdIc15);
+#endif
 }
 
 void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
@@ -883,6 +998,7 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
 
   gpioComIF->addGpios(gpioCookieRw);
 
+#if OBSW_ADD_RW == 1
   auto rw1SpiCookie =
       new SpiCookie(addresses::RW1, gpioIds::CS_RW1, q7s::SPI_RW_DEV, RwDefinitions::MAX_REPLY_SIZE,
                     spi::RW_MODE, spi::RW_SPEED, &rwSpiCallback::spiCallback, nullptr);
@@ -924,6 +1040,8 @@ void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
   rwHandler4->setStartUpImmediately();
 #endif
   rw4SpiCookie->setCallbackArgs(rwHandler4);
+
+#endif /* OBSW_ADD_RW == 1 */
 }
 
 void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
@@ -991,13 +1109,13 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
       gpioComIF, gpioIds::RS485_EN_TX_CLOCK, gpioIds::RS485_EN_TX_DATA);
 
   VirtualChannel* vc = nullptr;
-  vc = new VirtualChannel(ccsds::VC0, common::VC0_QUEUE_SIZE);
+  vc = new VirtualChannel(ccsds::VC0, common::VC0_QUEUE_SIZE, objects::CCSDS_HANDLER);
   ccsdsHandler->addVirtualChannel(ccsds::VC0, vc);
-  vc = new VirtualChannel(ccsds::VC1, common::VC1_QUEUE_SIZE);
+  vc = new VirtualChannel(ccsds::VC1, common::VC1_QUEUE_SIZE, objects::CCSDS_HANDLER);
   ccsdsHandler->addVirtualChannel(ccsds::VC1, vc);
-  vc = new VirtualChannel(ccsds::VC2, common::VC2_QUEUE_SIZE);
+  vc = new VirtualChannel(ccsds::VC2, common::VC2_QUEUE_SIZE, objects::CCSDS_HANDLER);
   ccsdsHandler->addVirtualChannel(ccsds::VC2, vc);
-  vc = new VirtualChannel(ccsds::VC3, common::VC3_QUEUE_SIZE);
+  vc = new VirtualChannel(ccsds::VC3, common::VC3_QUEUE_SIZE, objects::CCSDS_HANDLER);
   ccsdsHandler->addVirtualChannel(ccsds::VC3, vc);
 
   GpioCookie* gpioCookiePdec = new GpioCookie;
@@ -1034,6 +1152,50 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
 #endif /* BOARD_TE0720 == 0 */
 }
 
+void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF) {
+  // Create all GPIO components first
+  GpioCookie* plPcduGpios = new GpioCookie;
+  GpiodRegularByLineName* gpio = nullptr;
+  std::string consumer;
+  // Switch pins are active high
+  consumer = "PLPCDU_ENB_VBAT_0";
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_VBAT0, consumer, gpio::DIR_OUT,
+                                    gpio::Levels::LOW);
+  plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_VBAT0, gpio);
+  consumer = "PLPCDU_ENB_VBAT_1";
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_VBAT1, consumer, gpio::DIR_OUT,
+                                    gpio::Levels::LOW);
+  plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_VBAT1, gpio);
+  consumer = "PLPCDU_ENB_DRO";
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_DRO, consumer, gpio::DIR_OUT,
+                                    gpio::Levels::LOW);
+  plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_DRO, gpio);
+  consumer = "PLPCDU_ENB_HPA";
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_HPA, consumer, gpio::DIR_OUT,
+                                    gpio::Levels::LOW);
+  plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_HPA, gpio);
+  consumer = "PLPCDU_ENB_MPA";
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_MPA, consumer, gpio::DIR_OUT,
+                                    gpio::Levels::LOW);
+  plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_MPA, gpio);
+
+  consumer = "PLPCDU_ENB_X8";
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_X8, consumer, gpio::DIR_OUT,
+                                    gpio::Levels::LOW);
+  plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_X8, gpio);
+  consumer = "PLPCDU_ENB_TX";
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ENABLE_TX, consumer, gpio::DIR_OUT,
+                                    gpio::Levels::LOW);
+  plPcduGpios->addGpio(gpioIds::PLPCDU_ENB_TX, gpio);
+
+  // Chip select pin is active low
+  consumer = "PLPCDU_ADC_CS";
+  gpio = new GpiodRegularByLineName(q7s::gpioNames::PL_PCDU_ADC_CS, consumer, gpio::DIR_OUT,
+                                    gpio::Levels::HIGH);
+  plPcduGpios->addGpio(gpioIds::PLPCDU_ADC_CS, gpio);
+  gpioComIF->addGpios(plPcduGpios);
+}
+
 void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
 #if BOARD_TE0720 == 0
   new Q7STestTask(objects::TEST_TASK);
@@ -1055,18 +1217,18 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
   new LibgpiodTest(objects::LIBGPIOD_TEST, objects::GPIO_IF, gpioCookie);
 #endif
 
-#if BOARD_TE0720 == 1 && OBSW_TEST_SUS_HANDLER == 1
+#if BOARD_TE0720 == 1 && OBSW_TEST_SUS == 1
   GpioCookie* gpioCookieSus = new GpioCookie;
   GpiodRegular* chipSelectSus = new GpiodRegular(
       std::string("gpiochip1"), 9, std::string("Chip Select Sus Sensor"), gpio::DIR_OUT, 1);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_1, chipSelectSus);
+  gpioCookieSus->addGpio(gpioIds::CS_SUS_0, chipSelectSus);
   gpioComIF->addGpios(gpioCookieSus);
 
   SpiCookie* spiCookieSus =
-      new SpiCookie(addresses::SUS_1, std::string("/dev/spidev1.0"), SUS::MAX_CMD_SIZE,
+      new SpiCookie(addresses::SUS_0, std::string("/dev/spidev1.0"), SUS::MAX_CMD_SIZE,
                     spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
 
-  new SusHandler(objects::SUS_1, objects::SPI_COM_IF, spiCookieSus, gpioComIF, gpioIds::CS_SUS_1);
+  new SusHandler(objects::SUS_0, objects::SPI_COM_IF, spiCookieSus, gpioComIF, gpioIds::CS_SUS_0);
 #endif
 
 #if BOARD_TE0720 == 1 && OBSW_TEST_CCSDS_BRIDGE == 1
@@ -1084,7 +1246,7 @@ void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
                         gpioIds::PAPB_BUSY_N, gpioIds::PAPB_EMPTY);
 #endif
 
-#if BOARD_TE0720 == 1 && OBSW_TEST_RADIATION_SENSOR_HANDLER == 1
+#if BOARD_TE0720 == 1 && OBSW_TEST_RAD_SENSOR == 1
   GpioCookie* gpioCookieRadSensor = new GpioCookie;
   GpiodRegular* chipSelectRadSensor = new GpiodRegular(
       std::string("gpiochip1"), 0, std::string("Chip select radiation sensor"), gpio::DIR_OUT, 1);

bsp_q7s/core/ObjectFactory.h

@@ -13,6 +13,8 @@ void produce(void* args);
 
 void createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, UartComIF** uartComIF,
                                    SpiComIF** spiComIF, I2cComIF** i2cComIF);
+
+void createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF);
 void createTmpComponents();
 void createPcduComponents(LinuxLibgpioIF* gpioComIF);
 void createRadSensorComponent(LinuxLibgpioIF* gpioComIF);

bsp_q7s/devices/PlocMemoryDumper.cpp

@@ -10,7 +10,9 @@
 
 PlocMemoryDumper::PlocMemoryDumper(object_id_t objectId)
     : SystemObject(objectId), commandActionHelper(this), actionHelper(this, nullptr) {
-  commandQueue = QueueFactory::instance()->createMessageQueue(QUEUE_SIZE);
+  auto mqArgs = MqArgs(this->getObjectId());
+  commandQueue = QueueFactory::instance()->createMessageQueue(
+      QUEUE_SIZE, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 PlocMemoryDumper::~PlocMemoryDumper() {}

bsp_q7s/devices/PlocUpdater.cpp

@@ -8,7 +8,9 @@
 
 PlocUpdater::PlocUpdater(object_id_t objectId)
     : SystemObject(objectId), commandActionHelper(this), actionHelper(this, nullptr) {
-  commandQueue = QueueFactory::instance()->createMessageQueue(QUEUE_SIZE);
+  auto mqArgs = MqArgs(this->getObjectId());
+  commandQueue = QueueFactory::instance()->createMessageQueue(
+      QUEUE_SIZE, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 PlocUpdater::~PlocUpdater() {}

bsp_q7s/gpio/CMakeLists.txt

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

bsp_q7s/memory/FileSystemHandler.cpp

@@ -11,7 +11,9 @@
 
 FileSystemHandler::FileSystemHandler(object_id_t fileSystemHandler)
     : SystemObject(fileSystemHandler) {
-  mq = QueueFactory::instance()->createMessageQueue(FS_MAX_QUEUE_SIZE);
+  auto mqArgs = MqArgs(this->getObjectId());
+  mq = QueueFactory::instance()->createMessageQueue(FS_MAX_QUEUE_SIZE,
+                                                    MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 FileSystemHandler::~FileSystemHandler() { QueueFactory::instance()->deleteMessageQueue(mq); }

bsp_q7s/simple/simple.cpp

@@ -1,7 +1,6 @@
 #include "simple.h"
 
 #include "iostream"
-
 #include "q7sConfig.h"
 
 #if Q7S_SIMPLE_ADD_FILE_SYSTEM_TEST == 1

cmake/HardwareOsPostConfig.cmake

@@ -41,12 +41,12 @@ add_compile_options(
 	$<$<COMPILE_LANGUAGE:ASM>:${ASM_FLAGS}>
 )
 
-set(STRIPPED_OBSW_NAME ${OBSW_NAME}-stripped)
+set(STRIPPED_OBSW_NAME ${OBSW_BIN_NAME}-stripped)
 
 add_custom_command(
 	TARGET ${OBSW_NAME}
 	POST_BUILD
-	COMMAND ${CMAKE_STRIP} --strip-all ${OBSW_NAME} -o ${STRIPPED_OBSW_NAME}
+	COMMAND ${CMAKE_STRIP} --strip-all ${OBSW_BIN_NAME} -o ${STRIPPED_OBSW_NAME}
 	BYPRODUCTS ${STRIPPED_OBSW_NAME}
 	COMMENT "Generating stripped executable ${STRIPPED_OBSW_NAME}.."
 )

common/config/commonObjects.h

@@ -11,6 +11,7 @@ enum commonObjects: uint32_t {
     TMTC_BRIDGE = 0x50000300,
     TMTC_POLLING_TASK = 0x50000400,
     FILE_SYSTEM_HANDLER = 0x50000500,
+    SDC_MANAGER = 0x50000550,
     PTME = 0x50000600,
     PDEC_HANDLER = 0x50000700,
     CCSDS_HANDLER = 0x50000800,
@@ -36,6 +37,7 @@ enum commonObjects: uint32_t {
     GYRO_1_L3G_HANDLER = 0x44120111,
     GYRO_2_ADIS_HANDLER = 0x44120212,
     GYRO_3_L3G_HANDLER = 0x44120313,
+    PLPCDU_HANDLER = 0x44300000,
 
     IMTQ_HANDLER = 0x44140014,
     PLOC_MPSOC_HANDLER = 0x44330015,
@@ -62,19 +64,18 @@ enum commonObjects: uint32_t {
     RTD_IC_17 = 0x44420030,
     RTD_IC_18 = 0x44420031,
 
-    SUS_1 = 0x44120032,
+    SUS_0 = 0x44120032,
-    SUS_2 = 0x44120033,
+    SUS_1 = 0x44120033,
-    SUS_3 = 0x44120034,
+    SUS_2 = 0x44120034,
-    SUS_4 = 0x44120035,
+    SUS_3 = 0x44120035,
-    SUS_5 = 0x44120036,
+    SUS_4 = 0x44120036,
-    SUS_6 = 0x44120037,
+    SUS_5 = 0x44120037,
-    SUS_7 = 0x44120038,
+    SUS_6 = 0x44120038,
-    SUS_8 = 0x44120039,
+    SUS_7 = 0x44120039,
-    SUS_9 = 0x44120040,
+    SUS_8 = 0x44120040,
-    SUS_10 = 0x44120041,
+    SUS_9 = 0x44120041,
-    SUS_11 = 0x44120042,
+    SUS_10 = 0x44120042,
-    SUS_12 = 0x44120043,
+    SUS_11 = 0x44120043,
-    SUS_13 = 0x44120044,
 
     GPS_CONTROLLER = 0x44130045,
 

common/config/devConf.h

@@ -23,7 +23,13 @@ static constexpr uint32_t DEFAULT_L3G_SPEED = 976'000;
 static constexpr uint32_t L3G_TRANSITION_DELAY = 5000;
 static constexpr spi::SpiModes DEFAULT_L3G_MODE = spi::SpiModes::MODE_3;
 
-static constexpr uint32_t DEFAULT_MAX_1227_SPEED = 3'900'000;
+/**
+ * Some MAX1227 could not be reached with frequencies around 4 MHz. Maybe this is caused by
+ * the decoder and buffer circuits. Thus frequency is here defined to 1 MHz.
+ */
+static const uint32_t SUS_MAX1227_SPI_FREQ = 976'000;
+
+static constexpr uint32_t DEFAULT_MAX_1227_SPEED = 976'000;
 static constexpr spi::SpiModes DEFAULT_MAX_1227_MODE = spi::SpiModes::MODE_3;
 
 static constexpr uint32_t DEFAULT_ADIS16507_SPEED = 976'000;

generators/bsp_q7s_objects.csv

@@ -4,19 +4,18 @@
 0x43400001;THERMAL_CONTROLLER
 0x44120006;MGM_0_LIS3_HANDLER
 0x44120010;GYRO_0_ADIS_HANDLER
-0x44120032;SUS_1
+0x44120032;SUS_0
-0x44120033;SUS_2
+0x44120033;SUS_1
-0x44120034;SUS_3
+0x44120034;SUS_2
-0x44120035;SUS_4
+0x44120035;SUS_3
-0x44120036;SUS_5
+0x44120036;SUS_4
-0x44120037;SUS_6
+0x44120037;SUS_5
-0x44120038;SUS_7
+0x44120038;SUS_6
-0x44120039;SUS_8
+0x44120039;SUS_7
-0x44120040;SUS_9
+0x44120040;SUS_8
-0x44120041;SUS_10
+0x44120041;SUS_9
-0x44120042;SUS_11
+0x44120042;SUS_10
-0x44120043;SUS_12
+0x44120043;SUS_11
-0x44120044;SUS_13
 0x44120047;RW1
 0x44120107;MGM_1_RM3100_HANDLER
 0x44120111;GYRO_1_L3G_HANDLER
@@ -36,6 +35,7 @@
 0x44250002;PDU2_HANDLER
 0x44250003;ACU_HANDLER
 0x44260000;BPX_BATT_HANDLER
+0x44300000;PLPCDU_HANDLER
 0x443200A5;RAD_SENSOR
 0x44330000;PLOC_UPDATER
 0x44330001;PLOC_MEMORY_DUMPER
@@ -74,6 +74,7 @@
 0x50000300;TMTC_BRIDGE
 0x50000400;TMTC_POLLING_TASK
 0x50000500;FILE_SYSTEM_HANDLER
+0x50000550;SDC_MANAGER
 0x50000600;PTME
 0x50000700;PDEC_HANDLER
 0x50000800;CCSDS_HANDLER

generators/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief	Auto-generated object translation file.
  * @details
- * Contains 111 translations.
+ * Contains 112 translations.
- * Generated on: 2022-02-23 11:11:47
+ * Generated on: 2022-02-25 14:35:18
  */
 #include "translateObjects.h"
 
@@ -12,6 +12,7 @@ const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
 const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *MGM_0_LIS3_HANDLER_STRING = "MGM_0_LIS3_HANDLER";
 const char *GYRO_0_ADIS_HANDLER_STRING = "GYRO_0_ADIS_HANDLER";
+const char *SUS_0_STRING = "SUS_0";
 const char *SUS_1_STRING = "SUS_1";
 const char *SUS_2_STRING = "SUS_2";
 const char *SUS_3_STRING = "SUS_3";
@@ -23,8 +24,6 @@ const char *SUS_8_STRING = "SUS_8";
 const char *SUS_9_STRING = "SUS_9";
 const char *SUS_10_STRING = "SUS_10";
 const char *SUS_11_STRING = "SUS_11";
-const char *SUS_12_STRING = "SUS_12";
-const char *SUS_13_STRING = "SUS_13";
 const char *RW1_STRING = "RW1";
 const char *MGM_1_RM3100_HANDLER_STRING = "MGM_1_RM3100_HANDLER";
 const char *GYRO_1_L3G_HANDLER_STRING = "GYRO_1_L3G_HANDLER";
@@ -44,6 +43,7 @@ const char *PDU1_HANDLER_STRING = "PDU1_HANDLER";
 const char *PDU2_HANDLER_STRING = "PDU2_HANDLER";
 const char *ACU_HANDLER_STRING = "ACU_HANDLER";
 const char *BPX_BATT_HANDLER_STRING = "BPX_BATT_HANDLER";
+const char *PLPCDU_HANDLER_STRING = "PLPCDU_HANDLER";
 const char *RAD_SENSOR_STRING = "RAD_SENSOR";
 const char *PLOC_UPDATER_STRING = "PLOC_UPDATER";
 const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER";
@@ -82,6 +82,7 @@ const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
 const char *TMTC_BRIDGE_STRING = "TMTC_BRIDGE";
 const char *TMTC_POLLING_TASK_STRING = "TMTC_POLLING_TASK";
 const char *FILE_SYSTEM_HANDLER_STRING = "FILE_SYSTEM_HANDLER";
+const char *SDC_MANAGER_STRING = "SDC_MANAGER";
 const char *PTME_STRING = "PTME";
 const char *PDEC_HANDLER_STRING = "PDEC_HANDLER";
 const char *CCSDS_HANDLER_STRING = "CCSDS_HANDLER";
@@ -133,31 +134,29 @@ const char* translateObject(object_id_t object) {
 	case 0x44120010:
 		return GYRO_0_ADIS_HANDLER_STRING;
 	case 0x44120032:
-		return SUS_1_STRING;
+		return SUS_0_STRING;
 	case 0x44120033:
-		return SUS_2_STRING;
+		return SUS_1_STRING;
 	case 0x44120034:
-		return SUS_3_STRING;
+		return SUS_2_STRING;
 	case 0x44120035:
-		return SUS_4_STRING;
+		return SUS_3_STRING;
 	case 0x44120036:
-		return SUS_5_STRING;
+		return SUS_4_STRING;
 	case 0x44120037:
-		return SUS_6_STRING;
+		return SUS_5_STRING;
 	case 0x44120038:
-		return SUS_7_STRING;
+		return SUS_6_STRING;
 	case 0x44120039:
-		return SUS_8_STRING;
+		return SUS_7_STRING;
 	case 0x44120040:
-		return SUS_9_STRING;
+		return SUS_8_STRING;
 	case 0x44120041:
-		return SUS_10_STRING;
+		return SUS_9_STRING;
 	case 0x44120042:
-		return SUS_11_STRING;
+		return SUS_10_STRING;
 	case 0x44120043:
-		return SUS_12_STRING;
+		return SUS_11_STRING;
-	case 0x44120044:
-		return SUS_13_STRING;
 	case 0x44120047:
 		return RW1_STRING;
 	case 0x44120107:
@@ -196,6 +195,8 @@ const char* translateObject(object_id_t object) {
 		return ACU_HANDLER_STRING;
 	case 0x44260000:
 		return BPX_BATT_HANDLER_STRING;
+	case 0x44300000:
+		return PLPCDU_HANDLER_STRING;
 	case 0x443200A5:
 		return RAD_SENSOR_STRING;
 	case 0x44330000:
@@ -272,6 +273,8 @@ const char* translateObject(object_id_t object) {
 		return TMTC_POLLING_TASK_STRING;
 	case 0x50000500:
 		return FILE_SYSTEM_HANDLER_STRING;
+	case 0x50000550:
+		return SDC_MANAGER_STRING;
 	case 0x50000600:
 		return PTME_STRING;
 	case 0x50000700:

linux/boardtest/SpiTestClass.cpp

@@ -15,16 +15,20 @@
 
 #include <bitset>
 
+#if defined(XIPHOS_Q7S)
+#include "busConf.h"
+#endif
 #include "devices/gpioIds.h"
+#include "mission/devices/max1227.h"
 
 SpiTestClass::SpiTestClass(object_id_t objectId, GpioIF *gpioIF)
     : TestTask(objectId), gpioIF(gpioIF) {
   if (gpioIF == nullptr) {
     sif::error << "SpiTestClass::SpiTestClass: Invalid GPIO ComIF!" << std::endl;
   }
-  testMode = TestModes::MGM_LIS3MDL;
+  testMode = TestModes::MAX1227;
-  spiTransferStruct.rx_buf = reinterpret_cast<__u64>(recvBuffer.data());
+  spiTransferStruct[0].rx_buf = reinterpret_cast<__u64>(recvBuffer.data());
-  spiTransferStruct.tx_buf = reinterpret_cast<__u64>(sendBuffer.data());
+  setSendBuffer();
 }
 
 ReturnValue_t SpiTestClass::performOneShotAction() {
@@ -44,11 +48,25 @@ ReturnValue_t SpiTestClass::performOneShotAction() {
       performL3gTest(gyro1L3gd20ChipSelect);
       break;
     }
+    case (TestModes::MAX1227): {
+      performOneShotMax1227Test();
+      break;
+    }
   }
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t SpiTestClass::performPeriodicAction() { return HasReturnvaluesIF::RETURN_OK; }
+ReturnValue_t SpiTestClass::performPeriodicAction() {
+  switch (testMode) {
+    case (TestModes::MAX1227): {
+      performPeriodicMax1227Test();
+      break;
+    }
+    default:
+      break;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
 
 void SpiTestClass::performRm3100Test(uint8_t mgmId) {
   /* Configure all SPI chip selects and pull them high */
@@ -180,7 +198,7 @@ void SpiTestClass::performLis3MdlTest(uint8_t lis3Id) {
     return;
   }
   setSpiSpeedAndMode(fileDescriptor, spiMode, spiSpeed);
-  spiTransferStruct.delay_usecs = 0;
+  spiTransferStruct[0].delay_usecs = 0;
 
   uint8_t whoAmIRegVal = readStmRegister(fileDescriptor, currentGpioId, whoAmIReg, false);
   sif::info << "SpiTestClass::performLis3MdlTest: WHO AM I register 0b"
@@ -273,6 +291,354 @@ void SpiTestClass::performL3gTest(uint8_t l3gId) {
   sif::info << "Z: " << angVelocZ << std::endl;
 }
 
+void SpiTestClass::performOneShotMax1227Test() {
+  using namespace max1227;
+  adcCfg.testRadSensorExtConvWithDelay = false;
+  adcCfg.testRadSensorIntConv = false;
+
+  bool setAllSusOn = false;
+  bool susIntConv = false;
+  bool susExtConv = false;
+  if (setAllSusOn) {
+    for (uint8_t idx = 0; idx < 12; idx++) {
+      adcCfg.testSus[idx].doTest = true;
+    }
+  } else {
+    for (uint8_t idx = 0; idx < 12; idx++) {
+      adcCfg.testSus[idx].doTest = false;
+    }
+  }
+
+  if (susIntConv) {
+    for (uint8_t idx = 0; idx < 12; idx++) {
+      adcCfg.testSus[idx].intConv = true;
+    }
+  }
+  if (susExtConv) {
+    for (uint8_t idx = 0; idx < 12; idx++) {
+      adcCfg.testSus[idx].extConv = true;
+    }
+  }
+
+  adcCfg.plPcduAdcExtConv = true;
+  adcCfg.plPcduAdcIntConv = false;
+  // Is problematic, don't know why
+  adcCfg.plPcduAdcExtConvAsOne = false;
+  performMax1227Test();
+}
+
+void SpiTestClass::performPeriodicMax1227Test() {
+  using namespace max1227;
+  performMax1227Test();
+}
+
+void SpiTestClass::performMax1227Test() {
+#ifdef XIPHOS_Q7S
+  std::string deviceName = q7s::SPI_DEFAULT_DEV;
+#elif defined(RASPBERRY_PI)
+  std::string deviceName = "";
+#elif defined(EGSE)
+  std::string deviceName = "";
+#endif
+  int fd = 0;
+  UnixFileGuard fileHelper(deviceName, &fd, O_RDWR, "SpiComIF::initializeInterface");
+  if (fileHelper.getOpenResult()) {
+    sif::error << "SpiTestClass::performLis3Mdl3100Test: File descriptor could not be opened!"
+               << std::endl;
+    return;
+  }
+  uint32_t spiSpeed = 976'000;
+  spi::SpiModes spiMode = spi::SpiModes::MODE_3;
+  setSpiSpeedAndMode(fd, spiMode, spiSpeed);
+
+  max1227RadSensorTest(fd);
+  int idx = 0;
+  bool firstTest = true;
+  for (auto &susCfg : adcCfg.testSus) {
+    if (susCfg.doTest) {
+      if (firstTest) {
+        firstTest = false;
+        sif::info << "---------- SUS ADC Values -----------" << std::endl;
+      }
+      sif::info << "SUS " << std::setw(2) << idx << ": ";
+      max1227SusTest(fd, susCfg);
+    }
+    idx++;
+  }
+  max1227PlPcduTest(fd);
+}
+
+void SpiTestClass::max1227RadSensorTest(int fd) {
+  using namespace max1227;
+  if (adcCfg.testRadSensorExtConvWithDelay) {
+    sendBuffer[0] = max1227::buildResetByte(true);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, gpioIds::CS_RAD_SENSOR);
+    usleep(200);
+    sendBuffer[0] = max1227::buildSetupByte(ClkSel::EXT_CONV_EXT_TIMED, RefSel::INT_REF_WITH_WAKEUP,
+                                            DiffSel::NONE_0);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, gpioIds::CS_RAD_SENSOR);
+    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), 7, spiTransferStruct[0].len);
+    size_t tmpLen = spiTransferStruct[0].len;
+    spiTransferStruct[0].len = 1;
+    transfer(fd, gpioIds::CS_RAD_SENSOR);
+    std::memcpy(sendBuffer.data(), sendBuffer.data() + 1, tmpLen - 1);
+    spiTransferStruct[0].len = tmpLen - 1;
+    usleep(65);
+    transfer(fd, gpioIds::CS_RAD_SENSOR);
+    arrayprinter::print(recvBuffer.data(), 13, OutputType::HEX);
+    uint16_t adcRaw[8] = {};
+    adcRaw[0] = (recvBuffer[0] << 8) | recvBuffer[1];
+    adcRaw[1] = (recvBuffer[2] << 8) | recvBuffer[3];
+    adcRaw[2] = (recvBuffer[4] << 8) | recvBuffer[5];
+    adcRaw[3] = (recvBuffer[6] << 8) | recvBuffer[7];
+    adcRaw[4] = (recvBuffer[8] << 8) | recvBuffer[9];
+    adcRaw[5] = (recvBuffer[10] << 8) | recvBuffer[11];
+    adcRaw[6] = (recvBuffer[12] << 8) | recvBuffer[13];
+    adcRaw[7] = (recvBuffer[14] << 8) | recvBuffer[15];
+    arrayprinter::print(recvBuffer.data(), 17, OutputType::HEX);
+    for (int idx = 0; idx < 8; idx++) {
+      sif::info << "ADC raw " << idx << ": " << adcRaw[idx] << std::endl;
+    }
+    max1227::prepareExternallyClockedTemperatureRead(sendBuffer.data(), spiTransferStruct[0].len);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, gpioIds::CS_RAD_SENSOR);
+    usleep(65);
+    spiTransferStruct[0].len = 24;
+    std::memcpy(sendBuffer.data(), sendBuffer.data() + 1, 24);
+    transfer(fd, gpioIds::CS_RAD_SENSOR);
+    int16_t tempRaw = ((recvBuffer[22] & 0x0f) << 8) | recvBuffer[23];
+    float temp = max1227::getTemperature(tempRaw);
+    sif::info << "Temperature: " << temp << std::endl;
+  }
+  if (adcCfg.testRadSensorIntConv) {
+    sendBuffer[0] = max1227::buildResetByte(false);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, gpioIds::CS_RAD_SENSOR);
+    usleep(5);
+    // Now use internal conversion
+    sendBuffer[0] = max1227::buildSetupByte(ClkSel::INT_CONV_INT_TIMED_CNVST_AS_AIN,
+                                            RefSel::INT_REF_NO_WAKEUP, DiffSel::NONE_0);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, gpioIds::CS_RAD_SENSOR);
+    usleep(10);
+    sendBuffer[0] = buildConvByte(ScanModes::CHANNELS_0_TO_N, 7, true);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, gpioIds::CS_RAD_SENSOR);
+
+    usleep(65);
+    spiTransferStruct[0].len = 18;
+    // Shift out zeros
+    shiftOutZeros();
+    transfer(fd, gpioIds::CS_RAD_SENSOR);
+    setSendBuffer();
+
+    arrayprinter::print(recvBuffer.data(), 14);
+    uint16_t adcRaw[8] = {};
+    int16_t tempRaw = ((recvBuffer[0] & 0x0f) << 8) | recvBuffer[1];
+    sif::info << "Temperature: " << tempRaw * 0.125 << " C" << std::endl;
+    adcRaw[0] = (recvBuffer[2] << 8) | recvBuffer[3];
+    adcRaw[1] = (recvBuffer[4] << 8) | recvBuffer[5];
+    adcRaw[2] = (recvBuffer[6] << 8) | recvBuffer[7];
+    adcRaw[3] = (recvBuffer[8] << 8) | recvBuffer[9];
+    adcRaw[4] = (recvBuffer[10] << 8) | recvBuffer[11];
+    adcRaw[5] = (recvBuffer[12] << 8) | recvBuffer[13];
+    adcRaw[6] = (recvBuffer[14] << 8) | recvBuffer[15];
+    adcRaw[7] = (recvBuffer[16] << 8) | recvBuffer[17];
+    for (int idx = 0; idx < 8; idx++) {
+      sif::info << "ADC raw " << idx << ": " << adcRaw[idx] << std::endl;
+    }
+  }
+}
+
+void SpiTestClass::max1227SusTest(int fd, SusTestCfg &cfg) {
+  using namespace max1227;
+  if (cfg.extConv) {
+    sendBuffer[0] = max1227::buildResetByte(false);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, cfg.gpioId);
+
+    usleep(65);
+    sendBuffer[0] = max1227::buildSetupByte(ClkSel::EXT_CONV_EXT_TIMED, RefSel::INT_REF_NO_WAKEUP,
+                                            DiffSel::NONE_0);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, cfg.gpioId);
+
+    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), 5, spiTransferStruct[0].len);
+    transfer(fd, cfg.gpioId);
+    uint16_t adcRaw[6] = {};
+    adcRaw[0] = (recvBuffer[1] << 8) | recvBuffer[2];
+    adcRaw[1] = (recvBuffer[3] << 8) | recvBuffer[4];
+    adcRaw[2] = (recvBuffer[5] << 8) | recvBuffer[6];
+    adcRaw[3] = (recvBuffer[7] << 8) | recvBuffer[8];
+    adcRaw[4] = (recvBuffer[9] << 8) | recvBuffer[10];
+    adcRaw[5] = (recvBuffer[11] << 8) | recvBuffer[12];
+    sif::info << "Ext Conv [" << std::hex << std::setw(3);
+    for (int idx = 0; idx < 5; idx++) {
+      sif::info << adcRaw[idx];
+      if (idx < 6) {
+        sif::info << ",";
+      }
+    }
+    sif::info << std::dec << "]" << std::endl;  // | Temperature: " << temp << " C" << std::endl;
+  }
+  if (cfg.intConv) {
+    sendBuffer[0] = max1227::buildResetByte(false);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, cfg.gpioId);
+    usleep(65);
+    // Now use internal conversion
+    sendBuffer[0] = max1227::buildSetupByte(ClkSel::INT_CONV_INT_TIMED_CNVST_AS_AIN,
+                                            RefSel::INT_REF_NO_WAKEUP, DiffSel::NONE_0);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, cfg.gpioId);
+    usleep(10);
+    sendBuffer[0] = buildConvByte(ScanModes::CHANNELS_0_TO_N, 5, true);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, cfg.gpioId);
+
+    usleep(65);
+    spiTransferStruct[0].len = 14;
+    // Shift out zeros
+    shiftOutZeros();
+    transfer(fd, cfg.gpioId);
+    setSendBuffer();
+    // arrayprinter::print(recvBuffer.data(), 14);
+    float temp = static_cast<int16_t>(((recvBuffer[0] & 0x0f) << 8) | recvBuffer[1]) * 0.125;
+    uint16_t adcRaw[6] = {};
+    adcRaw[0] = (recvBuffer[2] << 8) | recvBuffer[3];
+    adcRaw[1] = (recvBuffer[4] << 8) | recvBuffer[5];
+    adcRaw[2] = (recvBuffer[6] << 8) | recvBuffer[7];
+    adcRaw[3] = (recvBuffer[8] << 8) | recvBuffer[9];
+    adcRaw[4] = (recvBuffer[10] << 8) | recvBuffer[11];
+    adcRaw[5] = (recvBuffer[12] << 8) | recvBuffer[13];
+    sif::info << "Int Conv [" << std::hex << std::setw(3);
+    for (int idx = 0; idx < 6; idx++) {
+      sif::info << adcRaw[idx];
+      if (idx < 5) {
+        sif::info << ",";
+      }
+    }
+    sif::info << std::dec << "] | T[C] " << temp << std::endl;
+  }
+}
+
+void SpiTestClass::max1227PlPcduTest(int fd) {
+  using namespace max1227;
+  if ((adcCfg.plPcduAdcExtConv or adcCfg.plPcduAdcIntConv or adcCfg.plPcduAdcExtConvAsOne) and
+      adcCfg.vbatSwitch) {
+    // This enables the ADC
+    ReturnValue_t result = gpioIF->pullHigh(gpioIds::PLPCDU_ENB_VBAT0);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return;
+    }
+    result = gpioIF->pullHigh(gpioIds::PLPCDU_ENB_VBAT1);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return;
+    }
+    adcCfg.vbatSwitch = false;
+    // Takes a bit of time until the ADC is usable
+    TaskFactory::delayTask(50);
+    sendBuffer[0] = max1227::buildResetByte(false);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, gpioIds::PLPCDU_ADC_CS);
+  }
+  if (adcCfg.plPcduAdcExtConv) {
+    sendBuffer[0] = max1227::buildSetupByte(ClkSel::EXT_CONV_EXT_TIMED, RefSel::INT_REF_NO_WAKEUP,
+                                            DiffSel::NONE_0);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, gpioIds::PLPCDU_ADC_CS);
+    uint8_t n = 11;
+    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), n, spiTransferStruct[0].len);
+    size_t dummy = 0;
+    max1227::prepareExternallyClockedTemperatureRead(sendBuffer.data() + spiTransferStruct[0].len,
+                                                     dummy);
+    // + 1 to account for temp conversion byte
+    spiTransferStruct[0].len += 1;
+    transfer(fd, gpioIds::PLPCDU_ADC_CS);
+    uint16_t adcRaw[n + 1] = {};
+    for (uint8_t idx = 0; idx < n + 1; idx++) {
+      adcRaw[idx] = (recvBuffer[idx * 2 + 1] << 8) | recvBuffer[idx * 2 + 2];
+    }
+    spiTransferStruct[0].len = 24;
+    // Shift out zeros
+    shiftOutZeros();
+    transfer(fd, gpioIds::PLPCDU_ADC_CS);
+    setSendBuffer();
+    int16_t tempRaw = ((recvBuffer[22] & 0x0f) << 8) | recvBuffer[23];
+    sif::info << "PL PCDU ADC ext conv [" << std::hex << std::setfill('0');
+    for (int idx = 0; idx < n + 1; idx++) {
+      sif::info << std::setw(3) << adcRaw[idx];
+      if (idx < n) {
+        sif::info << ",";
+      }
+    }
+    sif::info << "]" << std::endl;
+    sif::info << "Temperature: " << max1227::getTemperature(tempRaw) << " C" << std::endl;
+  }
+  if (adcCfg.plPcduAdcExtConvAsOne) {
+    sendBuffer[0] = max1227::buildSetupByte(ClkSel::EXT_CONV_EXT_TIMED, RefSel::INT_REF_NO_WAKEUP,
+                                            DiffSel::NONE_0);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, gpioIds::PLPCDU_ADC_CS);
+    uint8_t n = 11;
+    max1227::prepareExternallyClockedRead0ToN(sendBuffer.data(), n, spiTransferStruct[0].len);
+    max1227::prepareExternallyClockedTemperatureRead(sendBuffer.data() + spiTransferStruct[0].len,
+                                                     spiTransferStruct[0].len);
+    transfer(fd, gpioIds::PLPCDU_ADC_CS);
+    uint16_t adcRaw[n + 1] = {};
+    for (uint8_t idx = 0; idx < n + 1; idx++) {
+      adcRaw[idx] = (recvBuffer[idx * 2 + 1] << 8) | recvBuffer[idx * 2 + 2];
+    }
+    int16_t tempRaw = ((recvBuffer[spiTransferStruct[0].len - 2] & 0x0f) << 8) |
+                      recvBuffer[spiTransferStruct[0].len - 1];
+    sif::info << "PL PCDU ADC ext conv [" << std::hex << std::setfill('0');
+    for (int idx = 0; idx < n + 1; idx++) {
+      sif::info << std::setw(3) << adcRaw[idx];
+      if (idx < n) {
+        sif::info << ",";
+      }
+    }
+    sif::info << "]" << std::endl;
+    sif::info << "Temperature: " << max1227::getTemperature(tempRaw) << " C" << std::endl;
+  }
+  if (adcCfg.plPcduAdcIntConv) {
+    sendBuffer[0] = max1227::buildResetByte(true);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, gpioIds::PLPCDU_ADC_CS);
+    // Now use internal conversion
+    sendBuffer[0] = max1227::buildSetupByte(ClkSel::INT_CONV_INT_TIMED_CNVST_AS_AIN,
+                                            RefSel::INT_REF_NO_WAKEUP, DiffSel::NONE_0);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, gpioIds::PLPCDU_ADC_CS);
+    usleep(10);
+    uint8_t n = 11;
+    sendBuffer[0] = buildConvByte(ScanModes::CHANNELS_0_TO_N, n, true);
+    spiTransferStruct[0].len = 1;
+    transfer(fd, gpioIds::PLPCDU_ADC_CS);
+
+    usleep(65);
+    spiTransferStruct[0].len = 26;
+    // Shift out zeros
+    shiftOutZeros();
+    transfer(fd, gpioIds::PLPCDU_ADC_CS);
+    setSendBuffer();
+    uint16_t adcRaw[n + 1] = {};
+    int16_t tempRaw = ((recvBuffer[0] & 0x0f) << 8) | recvBuffer[1];
+    sif::info << "PL PCDU ADC int conv [" << std::hex << std::setfill('0');
+    for (int idx = 0; idx < n + 1; idx++) {
+      adcRaw[idx] = (recvBuffer[idx * 2 + 2] << 8) | recvBuffer[idx * 2 + 3];
+      sif::info << std::setw(3) << adcRaw[idx];
+      if (idx < n) {
+        sif::info << ",";
+      }
+    }
+    sif::info << "]" << std::endl;
+    sif::info << "Temperature: " << max1227::getTemperature(tempRaw) << " C" << std::endl;
+  }
+}
+
 void SpiTestClass::acsInit() {
   GpioCookie *gpioCookie = new GpioCookie();
 
@@ -348,8 +714,27 @@ void SpiTestClass::acsInit() {
 }
 
 void SpiTestClass::setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed) {
-  int mode_test = SPI_MODE_3;
+  int modeUnix = 0;
-  int retval = ioctl(spiFd, SPI_IOC_WR_MODE, &mode_test);  // reinterpret_cast<uint8_t*>(&mode));
+  switch (mode) {
+    case (spi::SpiModes::MODE_0): {
+      modeUnix = SPI_MODE_0;
+      break;
+    }
+    case (spi::SpiModes::MODE_1): {
+      modeUnix = SPI_MODE_1;
+      break;
+    }
+    case (spi::SpiModes::MODE_2): {
+      modeUnix = SPI_MODE_2;
+      break;
+    }
+    case (spi::SpiModes::MODE_3): {
+      modeUnix = SPI_MODE_3;
+      break;
+    }
+  }
+
+  int retval = ioctl(spiFd, SPI_IOC_WR_MODE, &modeUnix);  // reinterpret_cast<uint8_t*>(&mode));
   if (retval != 0) {
     utility::handleIoctlError("SpiTestClass::performRm3100Test: Setting SPI mode failed!");
   }
@@ -361,7 +746,7 @@ void SpiTestClass::setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t sp
 }
 
 void SpiTestClass::writeRegister(int fd, gpioId_t chipSelect, uint8_t reg, uint8_t value) {
-  spiTransferStruct.len = 2;
+  spiTransferStruct[0].len = 2;
   sendBuffer[0] = reg;
   sendBuffer[1] = value;
 
@@ -405,7 +790,7 @@ void SpiTestClass::writeMultipleRegisters(int fd, gpioId_t chipSelect, uint8_t r
 
   sendBuffer[0] = reg;
   std::memcpy(sendBuffer.data() + 1, values, len);
-  spiTransferStruct.len = len + 1;
+  spiTransferStruct[0].len = len + 1;
 
   if (gpioIF != nullptr and chipSelect != gpio::NO_GPIO) {
     gpioIF->pullLow(chipSelect);
@@ -429,13 +814,19 @@ void SpiTestClass::readMultipleStmRegisters(int fd, gpioId_t chipSelect, uint8_t
   readMultipleRegisters(fd, chipSelect, reg, reply, len);
 }
 
+void SpiTestClass::shiftOutZeros() { spiTransferStruct[0].tx_buf = 0; }
+
+void SpiTestClass::setSendBuffer() {
+  spiTransferStruct[0].tx_buf = reinterpret_cast<__u64>(sendBuffer.data());
+}
+
 void SpiTestClass::readMultipleRegisters(int fd, gpioId_t chipSelect, uint8_t reg, uint8_t *reply,
                                          size_t len) {
   if (reply == nullptr) {
     return;
   }
 
-  spiTransferStruct.len = len + 1;
+  spiTransferStruct[0].len = len + 1;
   sendBuffer[0] = reg | STM_READ_MASK;
 
   for (uint8_t idx = 0; idx < len; idx++) {
@@ -465,7 +856,7 @@ uint8_t SpiTestClass::readStmRegister(int fd, gpioId_t chipSelect, uint8_t reg,
 }
 
 uint8_t SpiTestClass::readRegister(int fd, gpioId_t chipSelect, uint8_t reg) {
-  spiTransferStruct.len = 2;
+  spiTransferStruct[0].len = 2;
   sendBuffer[0] = reg;
   sendBuffer[1] = 0;
 
@@ -481,3 +872,28 @@ uint8_t SpiTestClass::readRegister(int fd, gpioId_t chipSelect, uint8_t reg) {
   }
   return recvBuffer[1];
 }
+
+ReturnValue_t SpiTestClass::transfer(int fd, gpioId_t chipSelect = gpio::NO_GPIO) {
+  int retval = 0;
+  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
+  if (chipSelect != gpio::NO_GPIO) {
+    result = gpioIF->pullLow(chipSelect);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+  }
+
+  retval = ioctl(fd, SPI_IOC_MESSAGE(1), &spiTransferStruct);
+  if (retval < 0) {
+    utility::handleIoctlError("SpiTestClass::transfer: ioctl failed");
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+
+  if (chipSelect != gpio::NO_GPIO) {
+    result = gpioIF->pullHigh(chipSelect);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      return result;
+    }
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}

linux/boardtest/SpiTestClass.h

@@ -6,21 +6,40 @@
 #if defined(XIPHOS_Q7S)
 #include "busConf.h"
 #endif
-
 #include <fsfw_hal/common/gpio/GpioIF.h>
 #include <fsfw_hal/linux/spi/SpiCookie.h>
 #include <test/testtasks/TestTask.h>
 
 #include <vector>
 
+#include "devices/gpioIds.h"
+
+struct SusTestCfg {
+  SusTestCfg(bool doTest, gpioId_t gpioId) : gpioId(gpioId) {}
+  bool doTest = false;
+  const gpioId_t gpioId;
+  bool intConv = true;
+  bool extConv = false;
+};
+
+struct Max1227TestCfg {
+  bool testRadSensorExtConvWithDelay = false;
+  bool testRadSensorIntConv = false;
+  bool plPcduAdcExtConv = false;
+  bool plPcduAdcExtConvAsOne = false;
+  bool plPcduAdcIntConv = false;
+  bool vbatSwitch = true;
+
+  SusTestCfg testSus[12] = {
+      {false, gpioIds::CS_SUS_0}, {false, gpioIds::CS_SUS_1},  {false, gpioIds::CS_SUS_2},
+      {false, gpioIds::CS_SUS_3}, {false, gpioIds::CS_SUS_4},  {false, gpioIds::CS_SUS_5},
+      {false, gpioIds::CS_SUS_6}, {false, gpioIds::CS_SUS_7},  {false, gpioIds::CS_SUS_8},
+      {false, gpioIds::CS_SUS_9}, {false, gpioIds::CS_SUS_10}, {false, gpioIds::CS_SUS_11},
+  };
+};
 class SpiTestClass : public TestTask {
  public:
-  enum TestModes {
+  enum TestModes { NONE, MGM_LIS3MDL, MGM_RM3100, GYRO_L3GD20H, MAX1227 };
-    NONE,
-    MGM_LIS3MDL,
-    MGM_RM3100,
-    GYRO_L3GD20H,
-  };
 
   TestModes testMode;
 
@@ -31,14 +50,18 @@ class SpiTestClass : public TestTask {
 
  private:
   GpioIF* gpioIF;
+  Max1227TestCfg adcCfg = {};
 
   std::array<uint8_t, 128> recvBuffer;
   std::array<uint8_t, 128> sendBuffer;
-  struct spi_ioc_transfer spiTransferStruct = {};
+  struct spi_ioc_transfer spiTransferStruct[6] = {};
 
   void performRm3100Test(uint8_t mgmId);
   void performLis3MdlTest(uint8_t lis3Id);
   void performL3gTest(uint8_t l3gId);
+  void performOneShotMax1227Test();
+  void performPeriodicMax1227Test();
+  void performMax1227Test();
 
   /* ACS board specific code which pulls all GPIOs high */
   void acsInit();
@@ -55,6 +78,7 @@ class SpiTestClass : public TestTask {
   uint8_t gyro2AdisChipSelect = gpio::GYRO_2_BCM_PIN;
   uint8_t gyro3L3gd20ChipSelect = gpio::GYRO_3_BCM_PIN;
 #else
+
   uint8_t mgm0Lis3mdlChipSelect = 0;
   uint8_t mgm1Rm3100ChipSelect = 0;
   uint8_t gyro0AdisResetLine = 0;
@@ -69,6 +93,13 @@ class SpiTestClass : public TestTask {
   static constexpr uint8_t RM3100_READ_MASK = STM_READ_MASK;
   static constexpr uint8_t STM_AUTO_INCR_MASK = 0b0100'0000;
 
+  void shiftOutZeros();
+  void setSendBuffer();
+
+  void max1227RadSensorTest(int fd);
+  void max1227SusTest(int fd, SusTestCfg& cfg);
+  void max1227PlPcduTest(int fd);
+
   void setSpiSpeedAndMode(int spiFd, spi::SpiModes mode, uint32_t speed);
 
   void writeStmRegister(int fd, gpioId_t chipSelect, uint8_t reg, uint8_t value,
@@ -78,6 +109,7 @@ class SpiTestClass : public TestTask {
   void writeMultipleRegisters(int fd, gpioId_t chipSelect, uint8_t reg, uint8_t* values,
                               size_t len);
   void writeRegister(int fd, gpioId_t chipSelect, uint8_t reg, uint8_t value);
+  ReturnValue_t transfer(int fd, gpioId_t chipSelect);
 
   uint8_t readRm3100Register(int fd, gpioId_t chipSelect, uint8_t reg);
   uint8_t readStmRegister(int fd, gpioId_t chipSelect, uint8_t reg, bool autoIncrement);

linux/boardtest/UartTestClass.cpp

@@ -1,16 +1,11 @@
 #include "UartTestClass.h"
 
-#include <fsfw/tasks/TaskFactory.h>
-#if defined(RASPBERRY_PI)
-#include "rpiConfig.h"
-#elif defined(XIPHOS_Q7S)
-#include "q7sConfig.h"
-#endif
-
 #include <errno.h>  // Error integer and strerror() function
 #include <fcntl.h>  // Contains file controls like O_RDWR
+#include <fsfw/tasks/TaskFactory.h>
 #include <unistd.h>  // write(), read(), close()
 
+#include "OBSWConfig.h"
 #include "fsfw/globalfunctions/CRC.h"
 #include "fsfw/globalfunctions/DleEncoder.h"
 #include "fsfw/globalfunctions/arrayprinter.h"
@@ -42,7 +37,7 @@ ReturnValue_t UartTestClass::performPeriodicAction() {
 }
 
 void UartTestClass::gpsInit() {
-#if RPI_TEST_GPS_DEVICE == 1
+#if RPI_TEST_GPS_HANDLER == 1
   int result = lwgps_init(&gpsData);
   if (result == 0) {
     sif::warning << "lwgps_init error: " << result << std::endl;
@@ -90,7 +85,7 @@ void UartTestClass::gpsInit() {
 }
 
 void UartTestClass::gpsPeriodic() {
-#if RPI_TEST_GPS_DEVICE == 1
+#if RPI_TEST_GPS_HANDLER == 1
   int bytesRead = 0;
   do {
     bytesRead = read(serialPort, reinterpret_cast<void*>(recBuf.data()),
@@ -129,7 +124,7 @@ void UartTestClass::gpsPeriodic() {
 
 void UartTestClass::scexInit() {
 #if defined(RASPBERRY_PI)
-  std::string devname = "/dev/ttyUSB1";
+  std::string devname = "/dev/serial0";
 #else
   std::string devname = "/dev/ul-scex";
 #endif
@@ -156,6 +151,13 @@ void UartTestClass::scexInit() {
   tty.c_cc[VTIME] = 1;   // In units of 0.1 seconds
   tty.c_cc[VMIN] = 255;  // Read up to 255 bytes
 
+  // Q7S UART Lite has fixed baud rate. For other linux systems, set baud rate here.
+#if !defined(XIPHOS_Q7S)
+  if (cfsetispeed(&tty, B57600) != 0) {
+    sif::warning << "UartTestClass::scexInit: Setting baud rate failed" << std::endl;
+  }
+#endif
+
   if (tcsetattr(serialPort, TCSANOW, &tty) != 0) {
     sif::warning << "tcsetattr call failed with error [" << errno << ", " << strerror(errno)
                  << std::endl;
@@ -165,37 +167,12 @@ void UartTestClass::scexInit() {
 }
 
 void UartTestClass::scexPeriodic() {
-  auto dleEncoder = DleEncoder();
+  sif::info << "UartTestClass::scexInit: Sending ping command to SCEX" << std::endl;
-  std::array<uint8_t, 128> tmpCmdBuf = {};
+  int result = prepareScexPing();
-  // Send ping command
+  if (result != 0) {
-  tmpCmdBuf[0] = scex::CMD_PING;
-  // These two fields are the packet counter and the total packet count. Those are 1 and 1 for each
-  // telecommand so far
-  tmpCmdBuf[1] = 1;
-  tmpCmdBuf[2] = 1;
-  uint16_t userDataLen = 0;
-  tmpCmdBuf[3] = (userDataLen >> 8) & 0xff;
-  tmpCmdBuf[4] = userDataLen & 0xff;
-  uint16_t crc = CRC::crc16ccitt(tmpCmdBuf.data(), 5);
-  tmpCmdBuf[5] = (crc >> 8) & 0xff;
-  tmpCmdBuf[6] = crc & 0xff;
-
-  size_t encodedLen = 0;
-  ReturnValue_t result =
-      dleEncoder.encode(tmpCmdBuf.data(), 7, cmdBuf.data(), cmdBuf.size(), &encodedLen, true);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::warning << "UartTestClass::scexInit: Encoding failed" << std::endl;
     return;
-  }
+  };
-  arrayprinter::print(cmdBuf.data(), 9);
   size_t bytesWritten = write(serialPort, cmdBuf.data(), encodedLen);
-
-  if (bytesWritten != encodedLen) {
-    sif::warning << "Sending ping command to solar experiment failed" << std::endl;
-  }
-
-  TaskFactory::delayTask(20);
-  bytesWritten = write(serialPort, cmdBuf.data(), encodedLen);
   if (bytesWritten != encodedLen) {
     sif::warning << "Sending ping command to solar experiment failed" << std::endl;
   }
@@ -210,12 +187,35 @@ void UartTestClass::scexPeriodic() {
                    << ", " << strerror(errno) << "]" << std::endl;
       break;
     } else if (bytesRead >= static_cast<int>(recBuf.size())) {
-      sif::debug << "UartTestClass::performPeriodicAction: "
+      sif::debug << "UartTestClass::performPeriodicAction: recv buffer might not be large enough"
-                    "recv buffer might not be large enough"
                  << std::endl;
     } else if (bytesRead > 0) {
-      sif::info << "Received " << bytesRead << " from the Solar Cell Experiment:" << std::endl;
+      sif::info << "Received " << bytesRead
-      arrayprinter::print(recBuf.data(), bytesRead);
+                << " bytes from the Solar Cell Experiment:" << std::endl;
+      arrayprinter::print(recBuf.data(), bytesRead, OutputType::HEX, false);
     }
   } while (bytesRead > 0);
 }
+
+int UartTestClass::prepareScexPing() {
+  std::array<uint8_t, 128> tmpCmdBuf = {};
+  // Send ping command
+  tmpCmdBuf[0] = scex::CMD_PING;
+  // These two fields are the packet counter and the total packet count. Those are 1 and 1 for each
+  // telecommand so far
+  tmpCmdBuf[1] = 1;
+  tmpCmdBuf[2] = 1;
+  uint16_t userDataLen = 0;
+  tmpCmdBuf[3] = (userDataLen >> 8) & 0xff;
+  tmpCmdBuf[4] = userDataLen & 0xff;
+  uint16_t crc = CRC::crc16ccitt(tmpCmdBuf.data(), 5);
+  tmpCmdBuf[5] = (crc >> 8) & 0xff;
+  tmpCmdBuf[6] = crc & 0xff;
+  ReturnValue_t result =
+      dleEncoder.encode(tmpCmdBuf.data(), 7, cmdBuf.data(), cmdBuf.size(), &encodedLen, true);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    sif::warning << "UartTestClass::scexInit: Encoding failed" << std::endl;
+    return -1;
+  }
+  return 0;
+}

linux/boardtest/UartTestClass.h

@@ -1,6 +1,7 @@
 #ifndef LINUX_BOARDTEST_UARTTESTCLASS_H_
 #define LINUX_BOARDTEST_UARTTESTCLASS_H_
 
+#include <fsfw/globalfunctions/DleEncoder.h>
 #include <termios.h>  // Contains POSIX terminal control definitions
 
 #include <array>
@@ -28,7 +29,10 @@ class UartTestClass : public TestTask {
 
   void scexInit();
   void scexPeriodic();
+  int prepareScexPing();
   TestModes mode = TestModes::GPS;
+  DleEncoder dleEncoder = DleEncoder();
+  size_t encodedLen = 0;
   lwgps_t gpsData = {};
   struct termios tty = {};
   int serialPort = 0;

linux/devices/CMakeLists.txt

@@ -1,6 +1,5 @@
 target_sources(${OBSW_NAME} PRIVATE
-	SolarArrayDeploymentHandler.cpp
+	GPSHyperionLinuxController.cpp
-	SusHandler.cpp
 )
 
 add_subdirectory(startracker)

linux/devices/GPSHyperionLinuxController.cpp

@@ -1,8 +1,5 @@
 #include "GPSHyperionLinuxController.h"
 
-#include <cmath>
-
-#include "devicedefinitions/GPSDefinitions.h"
 #include "fsfw/datapool/PoolReadGuard.h"
 #include "fsfw/timemanager/Clock.h"
 
@@ -10,6 +7,7 @@
 #include <filesystem>
 #include <fstream>
 #endif
+#include <cmath>
 
 GPSHyperionLinuxController::GPSHyperionLinuxController(object_id_t objectId, object_id_t parentId,
                                                        bool debugHyperionGps)

linux/devices/GPSHyperionLinuxController.h

@@ -1,8 +1,8 @@
 #ifndef MISSION_DEVICES_GPSHYPERIONHANDLER_H_
 #define MISSION_DEVICES_GPSHYPERIONHANDLER_H_
 
-#include "devicedefinitions/GPSDefinitions.h"
 #include "fsfw/FSFW.h"
+#include "mission/devices/devicedefinitions/GPSDefinitions.h"
 #include "fsfw/controller/ExtendedControllerBase.h"
 #include "fsfw/devicehandlers/DeviceHandlerBase.h"
 

linux/devices/SusHandler.cpp

@@ -1,214 +0,0 @@
-#include "SusHandler.h"
-
-#include <fsfw/datapool/PoolReadGuard.h>
-#include <fsfw_hal/linux/spi/SpiComIF.h>
-
-#include "OBSWConfig.h"
-
-SusHandler::SusHandler(object_id_t objectId, object_id_t comIF, CookieIF *comCookie,
-                       LinuxLibgpioIF *gpioComIF, gpioId_t chipSelectId)
-    : DeviceHandlerBase(objectId, comIF, comCookie),
-      gpioComIF(gpioComIF),
-      chipSelectId(chipSelectId),
-      dataset(this) {
-  if (comCookie == NULL) {
-    sif::error << "SusHandler: Invalid com cookie" << std::endl;
-  }
-  if (gpioComIF == NULL) {
-    sif::error << "SusHandler: Invalid GpioComIF" << std::endl;
-  }
-}
-
-SusHandler::~SusHandler() {}
-
-ReturnValue_t SusHandler::performOperation(uint8_t counter) {
-  if (counter != FIRST_WRITE) {
-    DeviceHandlerBase::performOperation(counter);
-    return RETURN_OK;
-  }
-
-  if (mode != MODE_NORMAL) {
-    DeviceHandlerBase::performOperation(DeviceHandlerIF::SEND_WRITE);
-    return RETURN_OK;
-  }
-
-  /* If device is in normale mode the communication sequence is initiated here */
-  if (communicationStep == CommunicationStep::IDLE) {
-    communicationStep = CommunicationStep::WRITE_SETUP;
-  }
-
-  DeviceHandlerBase::performOperation(DeviceHandlerIF::SEND_WRITE);
-
-  return RETURN_OK;
-}
-
-ReturnValue_t SusHandler::initialize() {
-  ReturnValue_t result = RETURN_OK;
-  result = DeviceHandlerBase::initialize();
-  if (result != RETURN_OK) {
-    return result;
-  }
-  auto spiComIF = dynamic_cast<SpiComIF *>(communicationInterface);
-  if (spiComIF == nullptr) {
-    sif::debug << "SusHandler::initialize: Invalid communication interface" << std::endl;
-    return ObjectManagerIF::CHILD_INIT_FAILED;
-  }
-  spiMutex = spiComIF->getMutex();
-  if (spiMutex == nullptr) {
-    sif::debug << "SusHandler::initialize: Failed to get spi mutex" << std::endl;
-    return ObjectManagerIF::CHILD_INIT_FAILED;
-  }
-  return RETURN_OK;
-}
-
-void SusHandler::doStartUp() {
-#if OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP == 1
-  setMode(MODE_NORMAL);
-#else
-  setMode(_MODE_TO_ON);
-#endif
-}
-
-void SusHandler::doShutDown() { setMode(_MODE_POWER_DOWN); }
-
-ReturnValue_t SusHandler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
-  if (communicationStep == CommunicationStep::IDLE) {
-    return NOTHING_TO_SEND;
-  }
-
-  if (communicationStep == CommunicationStep::WRITE_SETUP) {
-    *id = SUS::WRITE_SETUP;
-    communicationStep = CommunicationStep::START_CONVERSIONS;
-  } else if (communicationStep == CommunicationStep::START_CONVERSIONS) {
-    *id = SUS::START_CONVERSIONS;
-    communicationStep = CommunicationStep::READ_CONVERSIONS;
-  } else if (communicationStep == CommunicationStep::READ_CONVERSIONS) {
-    *id = SUS::READ_CONVERSIONS;
-    communicationStep = CommunicationStep::IDLE;
-  }
-  return buildCommandFromCommand(*id, nullptr, 0);
-}
-
-ReturnValue_t SusHandler::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t SusHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
-                                                  const uint8_t *commandData,
-                                                  size_t commandDataLen) {
-  switch (deviceCommand) {
-    case (SUS::WRITE_SETUP): {
-      /**
-       * The sun sensor ADC is shutdown when CS is pulled high, so each time requesting a
-       * measurement the setup has to be rewritten. There must also be a little delay between
-       * the transmission of the setup byte and the first conversion. Thus the conversion
-       * will be performed in an extra step.
-       * Because the chip select is driven manually by the SusHandler the SPI bus must be
-       * protected with a mutex here.
-       */
-      ReturnValue_t result = spiMutex->lockMutex(timeoutType, timeoutMs);
-      if (result == MutexIF::MUTEX_TIMEOUT) {
-        sif::error << "SusHandler::buildCommandFromCommand: Mutex timeout" << std::endl;
-        return ERROR_LOCK_MUTEX;
-      } else if (result != HasReturnvaluesIF::RETURN_OK) {
-        sif::error << "SusHandler::buildCommandFromCommand: Failed to lock spi mutex" << std::endl;
-        return ERROR_LOCK_MUTEX;
-      }
-
-      gpioComIF->pullLow(chipSelectId);
-      cmdBuffer[0] = SUS::SETUP;
-      rawPacket = cmdBuffer;
-      rawPacketLen = 1;
-      return RETURN_OK;
-    }
-    case (SUS::START_CONVERSIONS): {
-      std::memset(cmdBuffer, 0, sizeof(cmdBuffer));
-      cmdBuffer[0] = SUS::CONVERSION;
-      rawPacket = cmdBuffer;
-      rawPacketLen = 2;
-      return RETURN_OK;
-    }
-    case (SUS::READ_CONVERSIONS): {
-      std::memset(cmdBuffer, 0, sizeof(cmdBuffer));
-      rawPacket = cmdBuffer;
-      rawPacketLen = SUS::SIZE_READ_CONVERSIONS;
-      return RETURN_OK;
-    }
-    default:
-      return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
-  }
-  return HasReturnvaluesIF::RETURN_FAILED;
-}
-
-void SusHandler::fillCommandAndReplyMap() {
-  this->insertInCommandMap(SUS::WRITE_SETUP);
-  this->insertInCommandMap(SUS::START_CONVERSIONS);
-  this->insertInCommandAndReplyMap(SUS::READ_CONVERSIONS, 1, &dataset, SUS::SIZE_READ_CONVERSIONS);
-}
-
-ReturnValue_t SusHandler::scanForReply(const uint8_t *start, size_t remainingSize,
-                                       DeviceCommandId_t *foundId, size_t *foundLen) {
-  *foundId = this->getPendingCommand();
-  *foundLen = remainingSize;
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-ReturnValue_t SusHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
-  switch (id) {
-    case SUS::READ_CONVERSIONS: {
-      PoolReadGuard readSet(&dataset);
-      dataset.temperatureCelcius = (*(packet) << 8 | *(packet + 1)) * 0.125;
-      dataset.ain0 = (*(packet + 2) << 8 | *(packet + 3));
-      dataset.ain1 = (*(packet + 4) << 8 | *(packet + 5));
-      dataset.ain2 = (*(packet + 6) << 8 | *(packet + 7));
-      dataset.ain3 = (*(packet + 8) << 8 | *(packet + 9));
-      dataset.ain4 = (*(packet + 10) << 8 | *(packet + 11));
-      dataset.ain5 = (*(packet + 12) << 8 | *(packet + 13));
-#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_SUS
-      sif::info << "SUS object id 0x" << std::hex << this->getObjectId()
-                << ", Temperature: " << dataset.temperatureCelcius << " °C" << std::endl;
-      sif::info << "SUS object id 0x" << std::hex << this->getObjectId() << ", AIN0: " << std::dec
-                << dataset.ain0 << std::endl;
-      sif::info << "SUS object id 0x" << std::hex << this->getObjectId() << ", AIN1: " << std::dec
-                << dataset.ain1 << std::endl;
-      sif::info << "SUS object id 0x" << std::hex << this->getObjectId() << ", AIN2: " << std::dec
-                << dataset.ain2 << std::endl;
-      sif::info << "SUS object id 0x" << std::hex << this->getObjectId() << ", AIN3: " << std::dec
-                << dataset.ain3 << std::endl;
-      sif::info << "SUS object id 0x" << std::hex << this->getObjectId() << ", AIN4: " << std::dec
-                << dataset.ain4 << std::endl;
-      sif::info << "SUS object id 0x" << std::hex << this->getObjectId() << ", AIN5: " << std::dec
-                << dataset.ain5 << std::endl;
-#endif
-      /** SUS can now be shutdown and thus the SPI bus released again */
-      gpioComIF->pullHigh(chipSelectId);
-      ReturnValue_t result = spiMutex->unlockMutex();
-      if (result != RETURN_OK) {
-        sif::error << "SusHandler::interpretDeviceReply: Failed to unlock spi mutex" << std::endl;
-        return ERROR_UNLOCK_MUTEX;
-      }
-      break;
-    }
-    default: {
-      sif::debug << "SusHandler::interpretDeviceReply: Unknown reply id" << std::endl;
-      return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
-    }
-  }
-  return HasReturnvaluesIF::RETURN_OK;
-}
-
-void SusHandler::setNormalDatapoolEntriesInvalid() {}
-
-uint32_t SusHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 1000; }
-
-ReturnValue_t SusHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
-                                                  LocalDataPoolManager &poolManager) {
-  localDataPoolMap.emplace(SUS::TEMPERATURE_C, new PoolEntry<float>({0.0}));
-  localDataPoolMap.emplace(SUS::AIN0, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(SUS::AIN1, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(SUS::AIN2, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(SUS::AIN3, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(SUS::AIN4, new PoolEntry<uint16_t>({0}));
-  localDataPoolMap.emplace(SUS::AIN5, new PoolEntry<uint16_t>({0}));
-  return HasReturnvaluesIF::RETURN_OK;
-}

linux/fsfwconfig/OBSWConfig.h.in

@@ -36,9 +36,9 @@ debugging. */
 
 #define OBSW_USE_CCSDS_IP_CORE                      1
 // Set to 1 if all telemetry should be sent to the PTME IP Core
-#define OBSW_TM_TO_PTME                             1
+#define OBSW_TM_TO_PTME                             0
 // Set to 1 if telecommands are received via the PDEC IP Core
-#define OBSW_TC_FROM_PDEC                           1
+#define OBSW_TC_FROM_PDEC                           0
 
 #define OBSW_ENABLE_TIMERS                          1
 #define OBSW_ADD_MGT                                1
@@ -53,6 +53,7 @@ debugging. */
 #define OBSW_ADD_RTD_DEVICES                        0
 #define OBSW_ADD_TMP_DEVICES                        0
 #define OBSW_ADD_RAD_SENSORS                        0
+#define OBSW_ADD_PL_PCDU                            0
 #define OBSW_ADD_SYRLINKS                           0
 #define OBSW_ENABLE_SYRLINKS_TRANSMIT_TIMEOUT       0
 #define OBSW_SYRLINKS_SIMULATED										  1
@@ -69,7 +70,7 @@ debugging. */
 /** All of the following flags should be disabled for mission code */
 /*******************************************************************/
 
-//! /* Can be used to switch device to NORMAL mode immediately */
+// Can be used to switch device to NORMAL mode immediately
 #define OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP    1
 #define OBSW_PRINT_MISSED_DEADLINES                 1
 
@@ -83,9 +84,17 @@ debugging. */
 #define OBSW_ADD_I2C_TEST_CODE                      0
 #define OBSW_ADD_UART_TEST_CODE                     0
 
+#define OBSW_TEST_ACS                               0
+#define OBSW_DEBUG_ACS                              0
+#define OBSW_TEST_SUS                               0
+#define OBSW_DEBUG_SUS                              0
+#define OBSW_TEST_RTD                               0
+#define OBSW_DEBUG_RTD                              0
+#define OBSW_TEST_RAD_SENSOR                        0
+#define OBSW_DEBUG_RAD_SENSOR                       0
+#define OBSW_TEST_PL_PCDU                           0
+#define OBSW_DEBUG_PL_PCDU                          0
 #define OBSW_TEST_LIBGPIOD                          0
-#define OBSW_TEST_RADIATION_SENSOR_HANDLER          0
-#define OBSW_TEST_SUS_HANDLER                       0
 #define OBSW_TEST_PLOC_HANDLER                      0
 #define OBSW_TEST_BPX_BATT                          0
 #define OBSW_TEST_CCSDS_BRIDGE                      0
@@ -93,7 +102,6 @@ debugging. */
 #define OBSW_TEST_TE7020_HEATER                     0
 #define OBSW_TEST_GPIO_OPEN_BY_LABEL                0
 #define OBSW_TEST_GPIO_OPEN_BY_LINE_NAME            0
-
 #define OBSW_DEBUG_P60DOCK                          0
 #define OBSW_DEBUG_BPX_BATT                         0
 #define OBSW_DEBUG_PDU1                             0
@@ -102,9 +110,6 @@ debugging. */
 #define OBSW_DEBUG_ACU                              0
 #define OBSW_DEBUG_SYRLINKS                         0
 #define OBSW_DEBUG_IMTQ                             0
-#define OBSW_DEBUG_RAD_SENSOR                       0
-#define OBSW_DEBUG_SUS                              0
-#define OBSW_DEBUG_RTD                              0
 #define OBSW_DEBUG_RW                               0
 #define OBSW_DEBUG_PLOC_MPSOC                       0
 #define OBSW_DEBUG_PLOC_SUPERVISOR                  0

linux/fsfwconfig/devices/addresses.cpp

@@ -1,7 +1 @@
-/**
- * \file logicalAddresses.cpp
- *
- * \date 06.11.2019
- */
-
 #include "addresses.h"

linux/fsfwconfig/devices/addresses.h

@@ -24,6 +24,7 @@ enum logicalAddresses : address_t {
 
   RAD_SENSOR = objects::RAD_SENSOR,
 
+  SUS_0 = objects::SUS_0,
   SUS_1 = objects::SUS_1,
   SUS_2 = objects::SUS_2,
   SUS_3 = objects::SUS_3,
@@ -35,8 +36,6 @@ enum logicalAddresses : address_t {
   SUS_9 = objects::SUS_9,
   SUS_10 = objects::SUS_10,
   SUS_11 = objects::SUS_11,
-  SUS_12 = objects::SUS_12,
-  SUS_13 = objects::SUS_13,
 
   /* Dummy and Test Addresses */
   DUMMY_ECHO = 129,
@@ -71,7 +70,8 @@ enum spiAddresses : address_t {
   RW1,
   RW2,
   RW3,
-  RW4
+  RW4,
+  PLPCDU_ADC
 };
 
 /* Addresses of devices supporting the CSP protocol */

linux/fsfwconfig/devices/gpioIds.h

@@ -54,6 +54,7 @@ enum gpioId_t {
   RTD_IC_17,
   RTD_IC_18,
 
+  CS_SUS_0,
   CS_SUS_1,
   CS_SUS_2,
   CS_SUS_3,
@@ -65,17 +66,16 @@ enum gpioId_t {
   CS_SUS_9,
   CS_SUS_10,
   CS_SUS_11,
-  CS_SUS_12,
-  CS_SUS_13,
 
+  SPI_MUX_BIT_0,
   SPI_MUX_BIT_1,
   SPI_MUX_BIT_2,
   SPI_MUX_BIT_3,
   SPI_MUX_BIT_4,
   SPI_MUX_BIT_5,
-  SPI_MUX_BIT_6,
 
   CS_RAD_SENSOR,
+  ENABLE_RADFET,
 
   PAPB_BUSY_N,
   PAPB_EMPTY,
@@ -110,7 +110,16 @@ enum gpioId_t {
   RS485_EN_RX_DATA,
   RS485_EN_RX_CLOCK,
 
-  BIT_RATE_SEL
+  BIT_RATE_SEL,
+
+  PLPCDU_ENB_VBAT0,
+  PLPCDU_ENB_VBAT1,
+  PLPCDU_ENB_DRO,
+  PLPCDU_ENB_X8,
+  PLPCDU_ENB_TX,
+  PLPCDU_ENB_HPA,
+  PLPCDU_ENB_MPA,
+  PLPCDU_ADC_CS
 };
 }
 

linux/fsfwconfig/objects/translateObjects.cpp

@@ -1,8 +1,8 @@
 /**
  * @brief	Auto-generated object translation file.
  * @details
- * Contains 111 translations.
+ * Contains 112 translations.
- * Generated on: 2022-02-23 11:11:47
+ * Generated on: 2022-02-25 14:35:18
  */
 #include "translateObjects.h"
 
@@ -12,6 +12,7 @@ const char *ACS_CONTROLLER_STRING = "ACS_CONTROLLER";
 const char *THERMAL_CONTROLLER_STRING = "THERMAL_CONTROLLER";
 const char *MGM_0_LIS3_HANDLER_STRING = "MGM_0_LIS3_HANDLER";
 const char *GYRO_0_ADIS_HANDLER_STRING = "GYRO_0_ADIS_HANDLER";
+const char *SUS_0_STRING = "SUS_0";
 const char *SUS_1_STRING = "SUS_1";
 const char *SUS_2_STRING = "SUS_2";
 const char *SUS_3_STRING = "SUS_3";
@@ -23,8 +24,6 @@ const char *SUS_8_STRING = "SUS_8";
 const char *SUS_9_STRING = "SUS_9";
 const char *SUS_10_STRING = "SUS_10";
 const char *SUS_11_STRING = "SUS_11";
-const char *SUS_12_STRING = "SUS_12";
-const char *SUS_13_STRING = "SUS_13";
 const char *RW1_STRING = "RW1";
 const char *MGM_1_RM3100_HANDLER_STRING = "MGM_1_RM3100_HANDLER";
 const char *GYRO_1_L3G_HANDLER_STRING = "GYRO_1_L3G_HANDLER";
@@ -44,6 +43,7 @@ const char *PDU1_HANDLER_STRING = "PDU1_HANDLER";
 const char *PDU2_HANDLER_STRING = "PDU2_HANDLER";
 const char *ACU_HANDLER_STRING = "ACU_HANDLER";
 const char *BPX_BATT_HANDLER_STRING = "BPX_BATT_HANDLER";
+const char *PLPCDU_HANDLER_STRING = "PLPCDU_HANDLER";
 const char *RAD_SENSOR_STRING = "RAD_SENSOR";
 const char *PLOC_UPDATER_STRING = "PLOC_UPDATER";
 const char *PLOC_MEMORY_DUMPER_STRING = "PLOC_MEMORY_DUMPER";
@@ -82,6 +82,7 @@ const char *PUS_PACKET_DISTRIBUTOR_STRING = "PUS_PACKET_DISTRIBUTOR";
 const char *TMTC_BRIDGE_STRING = "TMTC_BRIDGE";
 const char *TMTC_POLLING_TASK_STRING = "TMTC_POLLING_TASK";
 const char *FILE_SYSTEM_HANDLER_STRING = "FILE_SYSTEM_HANDLER";
+const char *SDC_MANAGER_STRING = "SDC_MANAGER";
 const char *PTME_STRING = "PTME";
 const char *PDEC_HANDLER_STRING = "PDEC_HANDLER";
 const char *CCSDS_HANDLER_STRING = "CCSDS_HANDLER";
@@ -133,31 +134,29 @@ const char* translateObject(object_id_t object) {
 	case 0x44120010:
 		return GYRO_0_ADIS_HANDLER_STRING;
 	case 0x44120032:
-		return SUS_1_STRING;
+		return SUS_0_STRING;
 	case 0x44120033:
-		return SUS_2_STRING;
+		return SUS_1_STRING;
 	case 0x44120034:
-		return SUS_3_STRING;
+		return SUS_2_STRING;
 	case 0x44120035:
-		return SUS_4_STRING;
+		return SUS_3_STRING;
 	case 0x44120036:
-		return SUS_5_STRING;
+		return SUS_4_STRING;
 	case 0x44120037:
-		return SUS_6_STRING;
+		return SUS_5_STRING;
 	case 0x44120038:
-		return SUS_7_STRING;
+		return SUS_6_STRING;
 	case 0x44120039:
-		return SUS_8_STRING;
+		return SUS_7_STRING;
 	case 0x44120040:
-		return SUS_9_STRING;
+		return SUS_8_STRING;
 	case 0x44120041:
-		return SUS_10_STRING;
+		return SUS_9_STRING;
 	case 0x44120042:
-		return SUS_11_STRING;
+		return SUS_10_STRING;
 	case 0x44120043:
-		return SUS_12_STRING;
+		return SUS_11_STRING;
-	case 0x44120044:
-		return SUS_13_STRING;
 	case 0x44120047:
 		return RW1_STRING;
 	case 0x44120107:
@@ -196,6 +195,8 @@ const char* translateObject(object_id_t object) {
 		return ACU_HANDLER_STRING;
 	case 0x44260000:
 		return BPX_BATT_HANDLER_STRING;
+	case 0x44300000:
+		return PLPCDU_HANDLER_STRING;
 	case 0x443200A5:
 		return RAD_SENSOR_STRING;
 	case 0x44330000:
@@ -272,6 +273,8 @@ const char* translateObject(object_id_t object) {
 		return TMTC_POLLING_TASK_STRING;
 	case 0x50000500:
 		return FILE_SYSTEM_HANDLER_STRING;
+	case 0x50000550:
+		return SDC_MANAGER_STRING;
 	case 0x50000600:
 		return PTME_STRING;
 	case 0x50000700:

linux/fsfwconfig/pollingsequence/pollingSequenceFactory.cpp

@@ -5,10 +5,6 @@
 #include <fsfw/serviceinterface/ServiceInterfaceStream.h>
 #include <fsfw/tasks/FixedTimeslotTaskIF.h>
 
-#include "OBSWConfig.h"
-#include "linux/devices/SusHandler.h"
-#include "objects/systemObjectList.h"
-
 ReturnValue_t pst::pstGpio(FixedTimeslotTaskIF *thisSequence) {
   // Length of a communication cycle
   uint32_t length = thisSequence->getPeriodMs();
@@ -153,6 +149,19 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
 #endif
 
 #if OBSW_ADD_SUN_SENSORS == 1
+
+  bool addSus0 = true;
+  bool addSus1 = true;
+  bool addSus2 = true;
+  bool addSus3 = true;
+  bool addSus4 = true;
+  bool addSus5 = true;
+  bool addSus6 = true;
+  bool addSus7 = true;
+  bool addSus8 = true;
+  bool addSus9 = true;
+  bool addSus10 = true;
+  bool addSus11 = true;
   /**
    * The sun sensor will be shutdown as soon as the chip select is pulled high. Thus all
    * requests to a sun sensor must be performed consecutively. Another reason for calling multiple
@@ -161,253 +170,157 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
    * One sun sensor communication sequence also blocks the SPI bus. So other devices can not be
    * inserted between the device handler cycles of one SUS.
    */
+  if (addSus0) {
     /* Write setup */
-  thisSequence->addSlot(objects::SUS_1, length * 0.9, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_0, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_1, length * 0.9, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_0, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_1, length * 0.9, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_0, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_1, length * 0.9, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_0, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_1, length * 0.9, DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::SUS_0, length * 0, DeviceHandlerIF::GET_READ);
-  /* Write setup */
-  thisSequence->addSlot(objects::SUS_1, length * 0.901, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_1, length * 0.901, SusHandler::FIRST_WRITE);
-  thisSequence->addSlot(objects::SUS_1, length * 0.901, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_1, length * 0.901, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_1, length * 0.901, DeviceHandlerIF::GET_READ);
-  /* Write setup */
-  thisSequence->addSlot(objects::SUS_1, length * 0.902, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_1, length * 0.902, SusHandler::FIRST_WRITE);
-  thisSequence->addSlot(objects::SUS_1, length * 0.902, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_1, length * 0.902, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_1, length * 0.902, DeviceHandlerIF::GET_READ);
 
-  /* Write setup */
+    thisSequence->addSlot(objects::SUS_0, length * 0.4, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_2, length * 0.903, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_0, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_2, length * 0.903, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_0, length * 0.4, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_2, length * 0.903, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_0, length * 0.4, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_2, length * 0.903, DeviceHandlerIF::SEND_READ);
+  }
-  thisSequence->addSlot(objects::SUS_2, length * 0.903, DeviceHandlerIF::GET_READ);
+  if (addSus1) {
-  /* Write setup */
+    thisSequence->addSlot(objects::SUS_1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_2, length * 0.904, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_1, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_2, length * 0.904, SusHandler::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_1, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_2, length * 0.904, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_1, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_2, length * 0.904, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_1, length * 0, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_2, length * 0.904, DeviceHandlerIF::GET_READ);
-  /* Write setup */
-  thisSequence->addSlot(objects::SUS_2, length * 0.905, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_2, length * 0.905, SusHandler::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_2, length * 0.905, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_2, length * 0.905, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_2, length * 0.905, DeviceHandlerIF::GET_READ);
 
-  /* Write setup */
+    thisSequence->addSlot(objects::SUS_1, length * 0.4, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_3, length * 0.8, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_1, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_3, length * 0.8, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_1, length * 0.4, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_3, length * 0.8, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_1, length * 0.4, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_3, length * 0.8, DeviceHandlerIF::SEND_READ);
+  }
-  thisSequence->addSlot(objects::SUS_3, length * 0.8, DeviceHandlerIF::GET_READ);
+  if (addSus2) {
-  /* Write setup */
+    thisSequence->addSlot(objects::SUS_2, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_3, length * 0.91, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_2, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_3, length * 0.91, SusHandler::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_2, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_3, length * 0.91, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_2, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_3, length * 0.91, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_2, length * 0, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_3, length * 0.91, DeviceHandlerIF::GET_READ);
-  /* Write setup */
-  thisSequence->addSlot(objects::SUS_3, length * 0.93, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_3, length * 0.93, SusHandler::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_3, length * 0.93, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_3, length * 0.93, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_3, length * 0.93, DeviceHandlerIF::GET_READ);
 
-  /* Write setup */
+    thisSequence->addSlot(objects::SUS_2, length * 0.4, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_4, length * 0.909, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_2, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_4, length * 0.909, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_2, length * 0.4, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_4, length * 0.909, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_2, length * 0.4, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_4, length * 0.909, DeviceHandlerIF::SEND_READ);
+  }
-  thisSequence->addSlot(objects::SUS_4, length * 0.909, DeviceHandlerIF::GET_READ);
+  if (addSus3) {
-  /* Write setup */
+    thisSequence->addSlot(objects::SUS_3, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_4, length * 0.91, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_3, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_4, length * 0.91, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_3, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_4, length * 0.91, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_3, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_4, length * 0.91, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_3, length * 0, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_4, length * 0.91, DeviceHandlerIF::GET_READ);
-  /* Write setup */
-  thisSequence->addSlot(objects::SUS_4, length * 0.911, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_4, length * 0.911, SusHandler::FIRST_WRITE);
-  thisSequence->addSlot(objects::SUS_4, length * 0.911, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_4, length * 0.911, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_4, length * 0.911, DeviceHandlerIF::GET_READ);
 
-  /* Write setup */
+    thisSequence->addSlot(objects::SUS_3, length * 0.4, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_5, length * 0.912, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_3, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_5, length * 0.912, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_3, length * 0.4, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_5, length * 0.912, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_3, length * 0.4, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_5, length * 0.912, DeviceHandlerIF::SEND_READ);
+  }
-  thisSequence->addSlot(objects::SUS_5, length * 0.912, DeviceHandlerIF::GET_READ);
+  if (addSus4) {
-  /* Write setup */
+    thisSequence->addSlot(objects::SUS_4, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_5, length * 0.913, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_4, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_5, length * 0.913, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_4, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_5, length * 0.913, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_4, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_5, length * 0.913, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_4, length * 0, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_5, length * 0.913, DeviceHandlerIF::GET_READ);
-  /* Write setup */
-  thisSequence->addSlot(objects::SUS_5, length * 0.914, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_5, length * 0.914, SusHandler::FIRST_WRITE);
-  thisSequence->addSlot(objects::SUS_5, length * 0.914, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_5, length * 0.914, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_5, length * 0.914, DeviceHandlerIF::GET_READ);
 
-  /* Write setup */
+    thisSequence->addSlot(objects::SUS_4, length * 0.4, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_6, length * 0.915, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_4, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_6, length * 0.915, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_4, length * 0.4, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_6, length * 0.915, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_4, length * 0.4, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_6, length * 0.915, DeviceHandlerIF::SEND_READ);
+  }
-  thisSequence->addSlot(objects::SUS_6, length * 0.915, DeviceHandlerIF::GET_READ);
+  if (addSus5) {
-  /* Start ADC conversions */
+    thisSequence->addSlot(objects::SUS_5, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_6, length * 0.916, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_5, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_6, length * 0.916, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_5, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_6, length * 0.916, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_5, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_6, length * 0.916, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_5, length * 0, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_6, length * 0.916, DeviceHandlerIF::GET_READ);
-  /* Read ADC conversions from inernal FIFO */
-  thisSequence->addSlot(objects::SUS_6, length * 0.917, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_6, length * 0.917, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_6, length * 0.917, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_6, length * 0.917, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_6, length * 0.917, DeviceHandlerIF::GET_READ);
 
-  /* Write setup */
+    thisSequence->addSlot(objects::SUS_5, length * 0.4, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_7, length * 0.918, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_5, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_7, length * 0.918, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_5, length * 0.4, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_7, length * 0.918, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_5, length * 0.4, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_7, length * 0.918, DeviceHandlerIF::SEND_READ);
+  }
-  thisSequence->addSlot(objects::SUS_7, length * 0.918, DeviceHandlerIF::GET_READ);
-  /* Start ADC conversions */
-  thisSequence->addSlot(objects::SUS_7, length * 0.919, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_7, length * 0.919, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_7, length * 0.919, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_7, length * 0.919, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_7, length * 0.919, DeviceHandlerIF::GET_READ);
-  /* Read ADC conversions from inernal FIFO */
-  thisSequence->addSlot(objects::SUS_7, length * 0.92, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_7, length * 0.92, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_7, length * 0.92, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_7, length * 0.92, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_7, length * 0.92, DeviceHandlerIF::GET_READ);
 
-  /* Write setup */
+  if (addSus6) {
-  thisSequence->addSlot(objects::SUS_8, length * 0.921, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_6, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_8, length * 0.921, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_6, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_8, length * 0.921, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_6, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_8, length * 0.921, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_6, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_8, length * 0.921, DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::SUS_6, length * 0, DeviceHandlerIF::GET_READ);
-  /* Start ADC conversions */
-  thisSequence->addSlot(objects::SUS_8, length * 0.922, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_8, length * 0.922, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_8, length * 0.922, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_8, length * 0.922, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_8, length * 0.922, DeviceHandlerIF::GET_READ);
-  /* Read ADC conversions from inernal FIFO */
-  thisSequence->addSlot(objects::SUS_8, length * 0.923, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_8, length * 0.923, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_8, length * 0.923, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_8, length * 0.923, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_8, length * 0.923, DeviceHandlerIF::GET_READ);
 
-  /* Write setup */
+    thisSequence->addSlot(objects::SUS_6, length * 0.4, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_9, length * 0.924, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_6, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_9, length * 0.924, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_6, length * 0.4, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_9, length * 0.924, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_6, length * 0.4, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_9, length * 0.924, DeviceHandlerIF::SEND_READ);
+  }
-  thisSequence->addSlot(objects::SUS_9, length * 0.924, DeviceHandlerIF::GET_READ);
-  /* Start ADC conversions */
-  thisSequence->addSlot(objects::SUS_9, length * 0.925, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_9, length * 0.925, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_9, length * 0.925, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_9, length * 0.925, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_9, length * 0.925, DeviceHandlerIF::GET_READ);
-  /* Read ADC conversions */
-  thisSequence->addSlot(objects::SUS_9, length * 0.926, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_9, length * 0.926, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_9, length * 0.926, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_9, length * 0.926, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_9, length * 0.926, DeviceHandlerIF::GET_READ);
 
-  /* Write setup */
+  if (addSus7) {
-  thisSequence->addSlot(objects::SUS_10, length * 0.927, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_7, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_10, length * 0.927, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_7, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_10, length * 0.927, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_7, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_10, length * 0.927, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_7, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_10, length * 0.927, DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::SUS_7, length * 0, DeviceHandlerIF::GET_READ);
-  /* Start ADC conversions */
-  thisSequence->addSlot(objects::SUS_10, length * 0.928, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_10, length * 0.928, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_10, length * 0.928, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_10, length * 0.928, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_10, length * 0.928, DeviceHandlerIF::GET_READ);
-  /* Read ADC conversions */
-  thisSequence->addSlot(objects::SUS_10, length * 0.929, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_10, length * 0.929, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_10, length * 0.929, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_10, length * 0.929, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_10, length * 0.929, DeviceHandlerIF::GET_READ);
 
-  /* Write setup */
+    thisSequence->addSlot(objects::SUS_7, length * 0.4, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_11, length * 0.93, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_7, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_11, length * 0.93, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_7, length * 0.4, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_11, length * 0.93, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_7, length * 0.4, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_11, length * 0.93, DeviceHandlerIF::SEND_READ);
+  }
-  thisSequence->addSlot(objects::SUS_11, length * 0.93, DeviceHandlerIF::GET_READ);
-  /* Start ADC conversions */
-  thisSequence->addSlot(objects::SUS_11, length * 0.931, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_11, length * 0.931, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_11, length * 0.931, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_11, length * 0.931, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_11, length * 0.931, DeviceHandlerIF::GET_READ);
-  /* Read ADC conversions */
-  thisSequence->addSlot(objects::SUS_11, length * 0.932, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_11, length * 0.932, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_11, length * 0.932, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_11, length * 0.932, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_11, length * 0.932, DeviceHandlerIF::GET_READ);
 
-  /* Write setup */
+  if (addSus8) {
-  thisSequence->addSlot(objects::SUS_12, length * 0.933, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_8, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_12, length * 0.933, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_8, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_12, length * 0.933, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_8, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_12, length * 0.933, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_8, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_12, length * 0.933, DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::SUS_8, length * 0, DeviceHandlerIF::GET_READ);
-  /* Start ADC conversions */
-  thisSequence->addSlot(objects::SUS_12, length * 0.934, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_12, length * 0.934, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_12, length * 0.934, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_12, length * 0.934, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_12, length * 0.934, DeviceHandlerIF::GET_READ);
-  /* Read ADC conversions */
-  thisSequence->addSlot(objects::SUS_12, length * 0.935, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_12, length * 0.935, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_12, length * 0.935, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_12, length * 0.935, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_12, length * 0.935, DeviceHandlerIF::GET_READ);
 
-  /* Write setup */
+    thisSequence->addSlot(objects::SUS_8, length * 0.4, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_13, length * 0.936, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_8, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_13, length * 0.936, SusHandler::FIRST_WRITE);
+    thisSequence->addSlot(objects::SUS_8, length * 0.4, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_13, length * 0.936, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_8, length * 0.4, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_13, length * 0.936, DeviceHandlerIF::SEND_READ);
+  }
-  thisSequence->addSlot(objects::SUS_13, length * 0.936, DeviceHandlerIF::GET_READ);
+
-  /* Start ADC conversions */
+  if (addSus9) {
-  thisSequence->addSlot(objects::SUS_13, length * 0.937, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_9, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
-  thisSequence->addSlot(objects::SUS_13, length * 0.937, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_9, length * 0, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_13, length * 0.937, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_9, length * 0, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_13, length * 0.937, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_9, length * 0, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_13, length * 0.937, DeviceHandlerIF::GET_READ);
+    thisSequence->addSlot(objects::SUS_9, length * 0, DeviceHandlerIF::GET_READ);
-  /* Read ADC conversions */
+    thisSequence->addSlot(objects::SUS_9, length * 0.4, DeviceHandlerIF::SEND_WRITE);
-  thisSequence->addSlot(objects::SUS_13, length * 0.938, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_9, length * 0.4, DeviceHandlerIF::GET_WRITE);
-  thisSequence->addSlot(objects::SUS_13, length * 0.938, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_9, length * 0.4, DeviceHandlerIF::SEND_READ);
-  thisSequence->addSlot(objects::SUS_13, length * 0.938, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_9, length * 0.4, DeviceHandlerIF::GET_READ);
-  thisSequence->addSlot(objects::SUS_13, length * 0.938, DeviceHandlerIF::SEND_READ);
+  }
-  thisSequence->addSlot(objects::SUS_13, length * 0.938, DeviceHandlerIF::GET_READ);
+
-#endif
+  if (addSus10) {
+    thisSequence->addSlot(objects::SUS_10, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_10, length * 0, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_10, length * 0, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_10, length * 0, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_10, length * 0, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::SUS_10, length * 0.4, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_10, length * 0.4, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_10, length * 0.4, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_10, length * 0.4, DeviceHandlerIF::GET_READ);
+  }
+
+  if (addSus11) {
+    thisSequence->addSlot(objects::SUS_11, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
+    thisSequence->addSlot(objects::SUS_11, length * 0, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_11, length * 0, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_11, length * 0, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_11, length * 0, DeviceHandlerIF::GET_READ);
+
+    thisSequence->addSlot(objects::SUS_11, length * 0.4, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::SUS_11, length * 0.4, DeviceHandlerIF::GET_WRITE);
+    thisSequence->addSlot(objects::SUS_11, length * 0.4, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::SUS_11, length * 0.4, DeviceHandlerIF::GET_READ);
+  }
+#endif /* OBSW_ADD_SUN_SENSORS == 1 */
 
 #if OBSW_ADD_RW == 1
   thisSequence->addSlot(objects::RW1, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
@@ -436,8 +349,8 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
 #endif
 
 #if OBSW_ADD_ACS_BOARD == 1 && OBSW_ADD_ACS_HANDLERS == 1
-  bool enableAside = true;
+  bool enableAside = false;
-  bool enableBside = false;
+  bool enableBside = true;
   if (enableAside) {
     // A side
     thisSequence->addSlot(objects::MGM_0_LIS3_HANDLER, length * 0,
@@ -452,21 +365,21 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
     thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.25,
                           DeviceHandlerIF::SEND_WRITE);
     thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::MGM_1_RM3100_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
 
     thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0,
                           DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.3, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE);
     thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::GYRO_0_ADIS_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
 
     thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0,
                           DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.35, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE);
     thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::GYRO_1_L3G_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
   }
 
@@ -474,7 +387,7 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
     // B side
     thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0,
                           DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE);
     thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
     thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::MGM_2_LIS3_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
@@ -484,21 +397,21 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
     thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.25,
                           DeviceHandlerIF::SEND_WRITE);
     thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::MGM_3_RM3100_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
 
     thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0,
                           DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.3, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE);
     thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::GYRO_2_ADIS_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
 
     thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0,
                           DeviceHandlerIF::PERFORM_OPERATION);
-    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.35, DeviceHandlerIF::SEND_WRITE);
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.25, DeviceHandlerIF::SEND_WRITE);
     thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.6, DeviceHandlerIF::GET_WRITE);
-    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.75, DeviceHandlerIF::SEND_READ);
+    thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.7, DeviceHandlerIF::SEND_READ);
     thisSequence->addSlot(objects::GYRO_3_L3G_HANDLER, length * 0.85, DeviceHandlerIF::GET_READ);
   }
 #endif /* OBSW_ADD_ACS_BOARD == 1 && OBSW_ADD_ACS_HANDLERS == 1 */
@@ -519,6 +432,7 @@ ReturnValue_t pst::pstSpi(FixedTimeslotTaskIF *thisSequence) {
 ReturnValue_t pst::pstI2c(FixedTimeslotTaskIF *thisSequence) {
   // Length of a communication cycle
   uint32_t length = thisSequence->getPeriodMs();
+  static_cast<void>(length);
 #if OBSW_ADD_MGT == 1
   thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::IMTQ_HANDLER, length * 0.2, DeviceHandlerIF::SEND_WRITE);
@@ -688,7 +602,7 @@ ReturnValue_t pst::pollingSequenceTE0720(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::PLOC_MPSOC_HANDLER, length * 0.8, DeviceHandlerIF::GET_READ);
 #endif
 
-#if OBSW_TEST_RADIATION_SENSOR_HANDLER == 1
+#if OBSW_TEST_RAD_SENSOR == 1
   thisSequence->addSlot(objects::RAD_SENSOR, length * 0, DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::RAD_SENSOR, length * 0.2, DeviceHandlerIF::SEND_WRITE);
   thisSequence->addSlot(objects::RAD_SENSOR, length * 0.4, DeviceHandlerIF::GET_WRITE);
@@ -696,7 +610,7 @@ ReturnValue_t pst::pollingSequenceTE0720(FixedTimeslotTaskIF *thisSequence) {
   thisSequence->addSlot(objects::RAD_SENSOR, length * 0.8, DeviceHandlerIF::GET_READ);
 #endif
 
-#if OBSW_TEST_SUS_HANDLER == 1
+#if OBSW_TEST_SUS == 1
   /* Write setup */
   thisSequence->addSlot(objects::SUS_1, length * 0.901, DeviceHandlerIF::PERFORM_OPERATION);
   thisSequence->addSlot(objects::SUS_1, length * 0.902, SusHandler::FIRST_WRITE);

misc/eclipse/.cproject

@@ -1177,7 +1177,7 @@
 							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.debugging.other.138952870" name="Other debugging flags" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.debugging.other"/>
 							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.showDevicesTab.69065720" name="showDevicesTab" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.showDevicesTab"/>
 							<targetPlatform archList="all" binaryParser="org.eclipse.cdt.core.ELF" id="ilg.gnuarmeclipse.managedbuild.cross.targetPlatform.1773865512" isAbstract="false" osList="all" superClass="ilg.gnuarmeclipse.managedbuild.cross.targetPlatform"/>
-							<builder arguments="--build . -j" buildPath="${workspace_loc:/eive-obsw/build-Watchdog}" command="cmake" enableCleanBuild="false" enabledIncrementalBuild="true" id="ilg.gnuarmeclipse.managedbuild.cross.builder.890124449" incrementalBuildTarget="" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" parallelBuildOn="true" parallelizationNumber="optimal" superClass="ilg.gnuarmeclipse.managedbuild.cross.builder"/>
+							<builder arguments="--build . --target eive-watchdog -j" buildPath="${workspace_loc:/eive-obsw/build-Debug-Watchdog}" command="cmake" enableCleanBuild="false" enabledIncrementalBuild="true" id="ilg.gnuarmeclipse.managedbuild.cross.builder.890124449" incrementalBuildTarget="" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" parallelBuildOn="true" parallelizationNumber="optimal" superClass="ilg.gnuarmeclipse.managedbuild.cross.builder"/>
 							<tool id="ilg.gnuarmeclipse.managedbuild.cross.tool.assembler.964799144" name="GNU Arm Cross Assembler" superClass="ilg.gnuarmeclipse.managedbuild.cross.tool.assembler">
 								<option id="ilg.gnuarmeclipse.managedbuild.cross.option.assembler.usepreprocessor.295289472" name="Use preprocessor" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.assembler.usepreprocessor" value="true" valueType="boolean"/>
 								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="ilg.gnuarmeclipse.managedbuild.cross.option.assembler.include.paths.111941431" name="Include paths (-I)" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.assembler.include.paths" valueType="includePath">
@@ -1343,7 +1343,7 @@
 							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.debugging.other.1135900144" name="Other debugging flags" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.debugging.other"/>
 							<option id="ilg.gnuarmeclipse.managedbuild.cross.option.showDevicesTab.2092395820" name="showDevicesTab" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.showDevicesTab"/>
 							<targetPlatform archList="all" binaryParser="org.eclipse.cdt.core.ELF" id="ilg.gnuarmeclipse.managedbuild.cross.targetPlatform.381962613" isAbstract="false" osList="all" superClass="ilg.gnuarmeclipse.managedbuild.cross.targetPlatform"/>
-							<builder arguments="--build . -j" buildPath="${workspace_loc:/eive-obsw/build-Release-Watchdog}" command="cmake" enableCleanBuild="false" enabledIncrementalBuild="true" id="ilg.gnuarmeclipse.managedbuild.cross.builder.1784164529" incrementalBuildTarget="" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" parallelBuildOn="true" parallelizationNumber="optimal" superClass="ilg.gnuarmeclipse.managedbuild.cross.builder"/>
+							<builder arguments="--build . --target eive-watchdog -j" buildPath="${workspace_loc:/eive-obsw/build-Release-Watchdog}" command="cmake" enableCleanBuild="false" enabledIncrementalBuild="true" id="ilg.gnuarmeclipse.managedbuild.cross.builder.1784164529" incrementalBuildTarget="" keepEnvironmentInBuildfile="false" managedBuildOn="false" name="Gnu Make Builder" parallelBuildOn="true" parallelizationNumber="optimal" superClass="ilg.gnuarmeclipse.managedbuild.cross.builder"/>
 							<tool id="ilg.gnuarmeclipse.managedbuild.cross.tool.assembler.926630835" name="GNU Arm Cross Assembler" superClass="ilg.gnuarmeclipse.managedbuild.cross.tool.assembler">
 								<option id="ilg.gnuarmeclipse.managedbuild.cross.option.assembler.usepreprocessor.243911424" name="Use preprocessor" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.assembler.usepreprocessor" value="true" valueType="boolean"/>
 								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="ilg.gnuarmeclipse.managedbuild.cross.option.assembler.include.paths.473023042" name="Include paths (-I)" superClass="ilg.gnuarmeclipse.managedbuild.cross.option.assembler.include.paths" valueType="includePath">
@@ -1496,10 +1496,10 @@
 		<configuration configurationName="q7s-watchdog-release">
 			<resource resourceType="PROJECT" workspacePath="/eive-obsw"/>
 		</configuration>
-		<configuration configurationName="eive-rpi-release-win"/>
 		<configuration configurationName="eive-fsfw-unittest">
 			<resource resourceType="PROJECT" workspacePath="/eive-obsw"/>
 		</configuration>
+		<configuration configurationName="eive-rpi-release-win"/>
 		<configuration configurationName="q7s-watchdog-debug"/>
 		<configuration configurationName="Default">
 			<resource resourceType="PROJECT" workspacePath="/eive_obsw"/>

mission/core/GenericFactory.cpp

@@ -69,7 +69,7 @@ void ObjectFactory::produceGenericObjects() {
                      objects::CCSDS_PACKET_DISTRIBUTOR);
 
   // Every TM packet goes through this funnel
-  new TmFunnel(objects::TM_FUNNEL);
+  new TmFunnel(objects::TM_FUNNEL, 50);
 
   // PUS service stack
   new Service1TelecommandVerification(objects::PUS_SERVICE_1_VERIFICATION, apid::EIVE_OBSW,
@@ -79,7 +79,7 @@ void ObjectFactory::produceGenericObjects() {
   new Service3Housekeeping(objects::PUS_SERVICE_3_HOUSEKEEPING, apid::EIVE_OBSW,
                            pus::PUS_SERVICE_3);
   new Service5EventReporting(objects::PUS_SERVICE_5_EVENT_REPORTING, apid::EIVE_OBSW,
-                             pus::PUS_SERVICE_5, 50);
+                             pus::PUS_SERVICE_5, 15, 45);
   new Service8FunctionManagement(objects::PUS_SERVICE_8_FUNCTION_MGMT, apid::EIVE_OBSW,
                                  pus::PUS_SERVICE_8, 3, 60);
   new Service9TimeManagement(objects::PUS_SERVICE_9_TIME_MGMT, apid::EIVE_OBSW, pus::PUS_SERVICE_9);

mission/devices/CMakeLists.txt

@@ -1,5 +1,4 @@
 target_sources(${LIB_EIVE_MISSION} PRIVATE
-	GPSHyperionLinuxController.cpp
     GomspaceDeviceHandler.cpp
     BpxBatteryHandler.cpp
     Tmp1075Handler.cpp
@@ -16,6 +15,7 @@ target_sources(${LIB_EIVE_MISSION} PRIVATE
     RadiationSensorHandler.cpp
     GyroADIS1650XHandler.cpp
     RwHandler.cpp
+    max1227.cpp
+    SusHandler.cpp
+    SolarArrayDeploymentHandler.cpp
 )
-
-

mission/devices/GyroADIS1650XHandler.cpp

@@ -20,10 +20,6 @@ GyroADIS1650XHandler::GyroADIS1650XHandler(object_id_t objectId, object_id_t dev
       primaryDataset(this),
       configDataset(this),
       breakCountdown() {
-#if FSFW_HAL_ADIS1650X_GYRO_DEBUG == 1
-  debugDivider = new PeriodicOperationDivider(5);
-#endif
-
 #if OBSW_ADIS1650X_LINUX_COM_IF == 1
   SpiCookie *cookie = dynamic_cast<SpiCookie *>(comCookie);
   if (cookie != nullptr) {
@@ -101,7 +97,7 @@ ReturnValue_t GyroADIS1650XHandler::buildCommandFromCommand(DeviceCommandId_t de
   switch (deviceCommand) {
     case (ADIS1650X::READ_OUT_CONFIG): {
       this->rawPacketLen = ADIS1650X::CONFIG_READOUT_SIZE;
-      uint8_t regList[5];
+      uint8_t regList[5] = {};
       regList[0] = ADIS1650X::DIAG_STAT_REG;
       regList[1] = ADIS1650X::FILTER_CTRL_REG;
       regList[2] = ADIS1650X::MSC_CTRL_REG;
@@ -305,8 +301,8 @@ ReturnValue_t GyroADIS1650XHandler::handleSensorData(const uint8_t *packet) {
         primaryDataset.setValidity(true, true);
       }
 
-#if FSFW_HAL_ADIS1650X_GYRO_DEBUG == 1
+      if (periodicPrintout) {
-      if (debugDivider->checkAndIncrement()) {
+        if (debugDivider.checkAndIncrement()) {
           sif::info << "GyroADIS1650XHandler: Angular velocities in deg / s" << std::endl;
           sif::info << "X: " << primaryDataset.angVelocX.value << std::endl;
           sif::info << "Y: " << primaryDataset.angVelocY.value << std::endl;
@@ -316,7 +312,7 @@ ReturnValue_t GyroADIS1650XHandler::handleSensorData(const uint8_t *packet) {
           sif::info << "Y: " << primaryDataset.accelY.value << std::endl;
           sif::info << "Z: " << primaryDataset.accelZ.value << std::endl;
         }
-#endif
+      }
 
       break;
     }
@@ -446,6 +442,9 @@ ReturnValue_t GyroADIS1650XHandler::spiSendCallback(SpiComIF *comIf, SpiCookie *
       }
 
       size_t idx = 0;
+      spi_ioc_transfer *transferStruct = cookie->getTransferStructHandle();
+      uint64_t origTx = transferStruct->tx_buf;
+      uint64_t origRx = transferStruct->rx_buf;
       while (idx < sendLen) {
         // Pull SPI CS low. For now, no support for active high given
         if (gpioId != gpio::NO_GPIO) {
@@ -471,11 +470,12 @@ ReturnValue_t GyroADIS1650XHandler::spiSendCallback(SpiComIF *comIf, SpiCookie *
         if (idx < sendLen) {
           usleep(ADIS1650X::STALL_TIME_MICROSECONDS);
         }
-        spi_ioc_transfer *transferStruct = cookie->getTransferStructHandle();
+
         transferStruct->tx_buf += 2;
         transferStruct->rx_buf += 2;
       }
-
+      transferStruct->tx_buf = origTx;
+      transferStruct->rx_buf = origRx;
       if (gpioId != gpio::NO_GPIO) {
         mutex->unlockMutex();
       }
@@ -486,4 +486,9 @@ ReturnValue_t GyroADIS1650XHandler::spiSendCallback(SpiComIF *comIf, SpiCookie *
 
 void GyroADIS1650XHandler::setToGoToNormalModeImmediately() { goToNormalMode = true; }
 
+void GyroADIS1650XHandler::enablePeriodicPrintouts(bool enable, uint8_t divider) {
+  periodicPrintout = enable;
+  debugDivider.setDivider(divider);
+}
+
 #endif /* OBSW_ADIS1650X_LINUX_COM_IF == 1 */

mission/devices/GyroADIS1650XHandler.h

@@ -23,6 +23,7 @@ class GyroADIS1650XHandler : public DeviceHandlerBase {
   GyroADIS1650XHandler(object_id_t objectId, object_id_t deviceCommunication, CookieIF *comCookie,
                        ADIS1650X::Type type);
 
+  void enablePeriodicPrintouts(bool enable, uint8_t divider);
   void setToGoToNormalModeImmediately();
 
   // DeviceHandlerBase abstract function implementation
@@ -69,13 +70,13 @@ class GyroADIS1650XHandler : public DeviceHandlerBase {
                                        size_t sendLen, void *args);
 #endif
 
-#if FSFW_HAL_ADIS1650X_GYRO_DEBUG == 1
-  PeriodicOperationDivider *debugDivider;
-#endif
   Countdown breakCountdown;
   void prepareWriteCommand(uint8_t startReg, uint8_t valueOne, uint8_t valueTwo);
 
   ReturnValue_t handleSensorData(const uint8_t *packet);
+
+  bool periodicPrintout = false;
+  PeriodicOperationDivider debugDivider = PeriodicOperationDivider(3);
 };
 
 #endif /* MISSION_DEVICES_GYROADIS16507HANDLER_H_ */

mission/devices/HeaterHandler.cpp

@@ -16,8 +16,9 @@ HeaterHandler::HeaterHandler(object_id_t setObjectId_, object_id_t gpioDriverId_
       mainLineSwitcherObjectId(mainLineSwitcherObjectId_),
       mainLineSwitch(mainLineSwitch_),
       actionHelper(this, nullptr) {
+  auto mqArgs = MqArgs(setObjectId_, static_cast<void*>(this));
   commandQueue = QueueFactory::instance()->createMessageQueue(
-      cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE);
+      cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 HeaterHandler::~HeaterHandler() {}

mission/devices/RadiationSensorHandler.cpp

@@ -1,11 +1,12 @@
 #include <OBSWConfig.h>
+#include <devices/gpioIds.h>
 #include <fsfw/datapool/PoolReadGuard.h>
 #include <mission/devices/RadiationSensorHandler.h>
 
 RadiationSensorHandler::RadiationSensorHandler(object_id_t objectId, object_id_t comIF,
-                                               CookieIF *comCookie)
+                                               CookieIF *comCookie, GpioIF *gpioIF)
-    : DeviceHandlerBase(objectId, comIF, comCookie), dataset(this) {
+    : DeviceHandlerBase(objectId, comIF, comCookie), dataset(this), gpioIF(gpioIF) {
-  if (comCookie == NULL) {
+  if (comCookie == nullptr) {
     sif::error << "RadiationSensorHandler: Invalid com cookie" << std::endl;
   }
 }
@@ -14,11 +15,13 @@ RadiationSensorHandler::~RadiationSensorHandler() {}
 
 void RadiationSensorHandler::doStartUp() {
   if (internalState == InternalState::CONFIGURED) {
-#if OBSW_SWITCH_TO_NORMAL_MODE_AFTER_STARTUP == 1
+    if (goToNormalMode) {
       setMode(MODE_NORMAL);
-#else
+    }
+
+    else {
       setMode(_MODE_TO_ON);
-#endif
+    }
   }
 }
 
@@ -66,6 +69,14 @@ ReturnValue_t RadiationSensorHandler::buildCommandFromCommand(DeviceCommandId_t
       return RETURN_OK;
     }
     case (RAD_SENSOR::START_CONVERSION): {
+      ReturnValue_t result = gpioIF->pullHigh(gpioIds::ENABLE_RADFET);
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+#if OBSW_VERBOSE_LEVEL >= 1
+        sif::warning << "RadiationSensorHandler::buildCommandFromCommand; Pulling RADFET Enale pin "
+                        "high failed"
+                     << std::endl;
+#endif
+      }
       /* First the fifo will be reset here */
       cmdBuffer[0] = RAD_SENSOR::RESET_DEFINITION;
       cmdBuffer[1] = RAD_SENSOR::CONVERSION_DEFINITION;
@@ -80,14 +91,6 @@ ReturnValue_t RadiationSensorHandler::buildCommandFromCommand(DeviceCommandId_t
       rawPacketLen = RAD_SENSOR::READ_SIZE;
       return RETURN_OK;
     }
-      //    case(RAD_SENSOR::AIN0_AND_TMP_CONVERSION): {
-      //        /* First the fifo will be reset here */
-      //        cmdBuffer[0] = RAD_SENSOR::RESET_DEFINITION;
-      //        cmdBuffer[1] = RAD_SENSOR::CONVERSION_DEFINITION;
-      //        rawPacket = cmdBuffer;
-      //        rawPacketLen = 2;
-      //        return RETURN_OK;
-      //    }
     default:
       return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
   }
@@ -109,6 +112,17 @@ ReturnValue_t RadiationSensorHandler::scanForReply(const uint8_t *start, size_t
     case RAD_SENSOR::START_CONVERSION:
     case RAD_SENSOR::WRITE_SETUP:
       return IGNORE_REPLY_DATA;
+    case RAD_SENSOR::READ_CONVERSIONS: {
+      ReturnValue_t result = gpioIF->pullLow(gpioIds::ENABLE_RADFET);
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+#if OBSW_VERBOSE_LEVEL >= 1
+        sif::warning << "RadiationSensorHandler::buildCommandFromCommand; Pulling RADFET Enale pin "
+                        "low failed"
+                     << std::endl;
+#endif
+      }
+      break;
+    }
     default:
       break;
   }
@@ -124,7 +138,8 @@ ReturnValue_t RadiationSensorHandler::interpretDeviceReply(DeviceCommandId_t id,
     case RAD_SENSOR::READ_CONVERSIONS: {
       uint8_t offset = 0;
       PoolReadGuard readSet(&dataset);
-      dataset.temperatureCelcius = (*(packet + offset) << 8 | *(packet + offset + 1)) * 0.125;
+      int16_t tempRaw = ((packet[offset] & 0x0f) << 8) | packet[offset + 1];
+      dataset.temperatureCelcius = tempRaw * 0.125;
       offset += 2;
       dataset.ain0 = (*(packet + offset) << 8 | *(packet + offset + 1));
       offset += 2;
@@ -138,7 +153,7 @@ ReturnValue_t RadiationSensorHandler::interpretDeviceReply(DeviceCommandId_t id,
       offset += 2;
       dataset.ain7 = (*(packet + offset) << 8 | *(packet + offset + 1));
 
-#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_RAD_SENSOR
+#if OBSW_VERBOSE_LEVEL >= 1 && OBSW_DEBUG_RAD_SENSOR == 1
       sif::info << "Radiation sensor temperature: " << dataset.temperatureCelcius << " °C"
                 << std::endl;
       sif::info << "Radiation sensor ADC value channel 0: " << dataset.ain0 << std::endl;
@@ -158,8 +173,6 @@ ReturnValue_t RadiationSensorHandler::interpretDeviceReply(DeviceCommandId_t id,
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-void RadiationSensorHandler::setNormalDatapoolEntriesInvalid() {}
-
 uint32_t RadiationSensorHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) {
   return 5000;
 }
@@ -175,3 +188,5 @@ ReturnValue_t RadiationSensorHandler::initializeLocalDataPool(localpool::DataPoo
   localDataPoolMap.emplace(RAD_SENSOR::AIN7, new PoolEntry<uint16_t>({0}));
   return HasReturnvaluesIF::RETURN_OK;
 }
+
+void RadiationSensorHandler::setToGoToNormalModeImmediately() { this->goToNormalMode = true; }

mission/devices/RadiationSensorHandler.h

@@ -4,6 +4,8 @@
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 #include <mission/devices/devicedefinitions/RadSensorDefinitions.h>
 
+class GpioIF;
+
 /**
  * @brief	This is the device handler class for radiation sensor on the OBC IF Board. The
  * sensor is based on the MAX1227 ADC converter.
@@ -14,8 +16,10 @@
  */
 class RadiationSensorHandler : public DeviceHandlerBase {
  public:
-  RadiationSensorHandler(object_id_t objectId, object_id_t comIF, CookieIF *comCookie);
+  RadiationSensorHandler(object_id_t objectId, object_id_t comIF, CookieIF *comCookie,
+                         GpioIF *gpioIF);
   virtual ~RadiationSensorHandler();
+  void setToGoToNormalModeImmediately();
 
  protected:
   void doStartUp() override;
@@ -28,7 +32,6 @@ class RadiationSensorHandler : public DeviceHandlerBase {
   ReturnValue_t scanForReply(const uint8_t *start, size_t remainingSize, DeviceCommandId_t *foundId,
                              size_t *foundLen) override;
   ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
-  void setNormalDatapoolEntriesInvalid() override;
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
@@ -39,9 +42,10 @@ class RadiationSensorHandler : public DeviceHandlerBase {
   enum class InternalState { SETUP, CONFIGURED };
 
   RAD_SENSOR::RadSensorDataset dataset;
-
   static const uint8_t MAX_CMD_LEN = RAD_SENSOR::READ_SIZE;
+  GpioIF *gpioIF = nullptr;
 
+  bool goToNormalMode = false;
   uint8_t cmdBuffer[MAX_CMD_LEN];
   InternalState internalState = InternalState::SETUP;
   CommunicationStep communicationStep = CommunicationStep::START_CONVERSION;

mission/devices/SolarArrayDeploymentHandler.cpp

@@ -21,8 +21,9 @@ SolarArrayDeploymentHandler::SolarArrayDeploymentHandler(object_id_t setObjectId
       deplSA2(deplSA2),
       burnTimeMs(burnTimeMs),
       actionHelper(this, nullptr) {
+  auto mqArgs = MqArgs(setObjectId_, static_cast<void*>(this));
   commandQueue = QueueFactory::instance()->createMessageQueue(
-      cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE);
+      cmdQueueSize, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 SolarArrayDeploymentHandler::~SolarArrayDeploymentHandler() {}

mission/devices/SusHandler.cpp

@@ -0,0 +1,233 @@
+#include "SusHandler.h"
+
+#include <fsfw/datapool/PoolReadGuard.h>
+#include <fsfw/globalfunctions/arrayprinter.h>
+
+#include "OBSWConfig.h"
+
+SusHandler::SusHandler(object_id_t objectId, uint8_t susIdx, object_id_t comIF, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comIF, comCookie), divider(5), dataset(this), susIdx(susIdx) {}
+
+SusHandler::~SusHandler() {}
+
+ReturnValue_t SusHandler::initialize() {
+  ReturnValue_t result = RETURN_OK;
+  result = DeviceHandlerBase::initialize();
+  if (result != RETURN_OK) {
+    return result;
+  }
+  return RETURN_OK;
+}
+
+void SusHandler::doStartUp() {
+  if (comState == ComStates::IDLE) {
+    comState = ComStates::WRITE_SETUP;
+    commandExecuted = false;
+  }
+  if (comState == ComStates::WRITE_SETUP) {
+    if (commandExecuted) {
+      if (goToNormalModeImmediately) {
+        setMode(MODE_NORMAL);
+      } else {
+        setMode(_MODE_TO_ON);
+      }
+      commandExecuted = false;
+      if (clkMode == ClkModes::INT_CLOCKED) {
+        comState = ComStates::START_INT_CLOCKED_CONVERSIONS;
+      } else {
+        comState = ComStates::EXT_CLOCKED_CONVERSIONS;
+      }
+    }
+  }
+}
+
+void SusHandler::doShutDown() { setMode(_MODE_POWER_DOWN); }
+
+ReturnValue_t SusHandler::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  switch (comState) {
+    case (ComStates::IDLE): {
+      break;
+    }
+    case (ComStates::WRITE_SETUP): {
+      *id = SUS::WRITE_SETUP;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    case (ComStates::EXT_CLOCKED_CONVERSIONS): {
+      *id = SUS::READ_EXT_TIMED_CONVERSIONS;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    case (ComStates::START_INT_CLOCKED_CONVERSIONS): {
+      *id = SUS::START_INT_TIMED_CONVERSIONS;
+      comState = ComStates::READ_INT_CLOCKED_CONVERSIONS;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    case (ComStates::READ_INT_CLOCKED_CONVERSIONS): {
+      *id = SUS::READ_INT_TIMED_CONVERSIONS;
+      comState = ComStates::START_INT_CLOCKED_CONVERSIONS;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+    case (ComStates::EXT_CLOCKED_TEMP): {
+      *id = SUS::READ_EXT_TIMED_TEMPS;
+      return buildCommandFromCommand(*id, nullptr, 0);
+    }
+  }
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t SusHandler::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  if (comState == ComStates::WRITE_SETUP) {
+    *id = SUS::WRITE_SETUP;
+    return buildCommandFromCommand(*id, nullptr, 0);
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SusHandler::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                  const uint8_t *commandData,
+                                                  size_t commandDataLen) {
+  using namespace max1227;
+  switch (deviceCommand) {
+    case (SUS::WRITE_SETUP): {
+      if (clkMode == ClkModes::INT_CLOCKED) {
+        cmdBuffer[0] = SUS::SETUP_INT_CLOKED;
+      } else {
+        cmdBuffer[0] = SUS::SETUP_EXT_CLOCKED;
+      }
+
+      rawPacket = cmdBuffer;
+      rawPacketLen = 1;
+      break;
+    }
+    case (SUS::START_INT_TIMED_CONVERSIONS): {
+      std::memset(cmdBuffer, 0, sizeof(cmdBuffer));
+      cmdBuffer[0] = max1227::buildResetByte(true);
+      cmdBuffer[1] = SUS::CONVERSION;
+      rawPacket = cmdBuffer;
+      rawPacketLen = 2;
+      break;
+    }
+    case (SUS::READ_INT_TIMED_CONVERSIONS): {
+      std::memset(cmdBuffer, 0, sizeof(cmdBuffer));
+      rawPacket = cmdBuffer;
+      rawPacketLen = SUS::SIZE_READ_INT_CONVERSIONS;
+      break;
+    }
+    case (SUS::READ_EXT_TIMED_CONVERSIONS): {
+      std::memset(cmdBuffer, 0, sizeof(cmdBuffer));
+      rawPacket = cmdBuffer;
+      for (uint8_t idx = 0; idx < 6; idx++) {
+        cmdBuffer[idx * 2] = buildConvByte(ScanModes::N_ONCE, idx, false);
+        cmdBuffer[idx * 2 + 1] = 0;
+      }
+      cmdBuffer[12] = 0x00;
+      rawPacketLen = SUS::SIZE_READ_EXT_CONVERSIONS;
+      break;
+    }
+    case (SUS::READ_EXT_TIMED_TEMPS): {
+      cmdBuffer[0] = buildConvByte(ScanModes::N_ONCE, 0, true);
+      std::memset(cmdBuffer + 1, 0, 24);
+      rawPacket = cmdBuffer;
+      rawPacketLen = 25;
+      break;
+    }
+    default:
+      return DeviceHandlerIF::COMMAND_NOT_IMPLEMENTED;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+void SusHandler::fillCommandAndReplyMap() {
+  insertInCommandAndReplyMap(SUS::WRITE_SETUP, 1);
+  insertInCommandAndReplyMap(SUS::START_INT_TIMED_CONVERSIONS, 1);
+  insertInCommandAndReplyMap(SUS::READ_INT_TIMED_CONVERSIONS, 1, &dataset,
+                             SUS::SIZE_READ_INT_CONVERSIONS);
+  insertInCommandAndReplyMap(SUS::READ_EXT_TIMED_CONVERSIONS, 1, &dataset,
+                             SUS::SIZE_READ_EXT_CONVERSIONS);
+  insertInCommandAndReplyMap(SUS::READ_EXT_TIMED_TEMPS, 1);
+}
+
+ReturnValue_t SusHandler::scanForReply(const uint8_t *start, size_t remainingSize,
+                                       DeviceCommandId_t *foundId, size_t *foundLen) {
+  *foundId = this->getPendingCommand();
+  *foundLen = remainingSize;
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+ReturnValue_t SusHandler::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  switch (id) {
+    case SUS::WRITE_SETUP: {
+      if (mode == _MODE_START_UP) {
+        commandExecuted = true;
+      }
+      return HasReturnvaluesIF::RETURN_OK;
+    }
+    case SUS::START_INT_TIMED_CONVERSIONS: {
+      return HasReturnvaluesIF::RETURN_OK;
+    }
+    case SUS::READ_INT_TIMED_CONVERSIONS: {
+      PoolReadGuard readSet(&dataset);
+
+      dataset.temperatureCelcius = max1227::getTemperature(((packet[0] & 0x0f) << 8) | packet[1]);
+      for (uint8_t idx = 0; idx < 6; idx++) {
+        dataset.channels[idx] = packet[idx * 2 + 2] << 8 | packet[idx * 2 + 3];
+      }
+      printDataset();
+      break;
+    }
+    case (SUS::READ_EXT_TIMED_CONVERSIONS): {
+      PoolReadGuard readSet(&dataset);
+      for (uint8_t idx = 0; idx < 6; idx++) {
+        dataset.channels[idx] = packet[idx * 2 + 1] << 8 | packet[idx * 2 + 2];
+      }
+      // Read temperature in next read cycle
+      if (clkMode == ClkModes::EXT_CLOCKED_WITH_TEMP) {
+        comState = ComStates::EXT_CLOCKED_TEMP;
+      }
+      printDataset();
+      break;
+    }
+    case (SUS::READ_EXT_TIMED_TEMPS): {
+      PoolReadGuard readSet(&dataset);
+      dataset.temperatureCelcius = max1227::getTemperature(((packet[23] & 0x0f) << 8) | packet[24]);
+      comState = ComStates::EXT_CLOCKED_CONVERSIONS;
+      break;
+    }
+    default: {
+      sif::debug << "SusHandler::interpretDeviceReply: Unknown reply id" << std::endl;
+      return DeviceHandlerIF::UNKNOWN_DEVICE_REPLY;
+    }
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+uint32_t SusHandler::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 2000; }
+
+ReturnValue_t SusHandler::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                  LocalDataPoolManager &poolManager) {
+  localDataPoolMap.emplace(SUS::TEMPERATURE_C, &tempC);
+  localDataPoolMap.emplace(SUS::CHANNEL_VEC, &channelVec);
+  return HasReturnvaluesIF::RETURN_OK;
+}
+
+void SusHandler::setToGoToNormalMode(bool enable) { this->goToNormalModeImmediately = enable; }
+
+void SusHandler::printDataset() {
+  if (periodicPrintout) {
+    if (divider.checkAndIncrement()) {
+      sif::info << "SUS ADC " << static_cast<int>(susIdx) << " hex [" << std::setfill('0')
+                << std::hex;
+      for (uint8_t idx = 0; idx < 6; idx++) {
+        sif::info << std::setw(3) << dataset.channels[idx];
+        if (idx < 6 - 1) {
+          sif::info << ",";
+        }
+      }
+      sif::info << "] | T[C] " << std::dec << dataset.temperatureCelcius.value << std::endl;
+    }
+  }
+}
+
+void SusHandler::enablePeriodicPrintout(bool enable, uint8_t divider) {
+  this->periodicPrintout = enable;
+  this->divider.setDivider(divider);
+}

mission/devices/SusHandler.h

@@ -2,16 +2,18 @@
 #define MISSION_DEVICES_SUSHANDLER_H_
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
-#include <fsfw_hal/linux/gpio/LinuxLibgpioIF.h>
 
 #include "devicedefinitions/SusDefinitions.h"
+#include "fsfw/globalfunctions/PeriodicOperationDivider.h"
+#include "mission/devices/max1227.h"
 
 /**
- * @brief	This is the device handler class for the SUS sensor. The sensor is
+ * @brief	This is the device handler class for the SUS sensor based on the MAX1227 ADC.
- *          based on the MAX1227 ADC. Details about the SUS electronic can be found at
- *          https://egit.irs.uni-stuttgart.de/eive/eive_dokumente/src/branch/master/400_Raumsegment/443_SunSensorDocumentation/release
  *
- * @details Datasheet of MAX1227: https://datasheets.maximintegrated.com/en/ds/MAX1227-MAX1231.pdf
+ * @details
+ * Datasheet of MAX1227: https://datasheets.maximintegrated.com/en/ds/MAX1227-MAX1231.pdf
+ * Details about the SUS electronic can be found at
+ * https://egit.irs.uni-stuttgart.de/eive/eive_dokumente/src/branch/master/400_Raumsegment/443_SunSensorDocumentation/release
  *
  * @note    When adding a SusHandler to the polling sequence table make sure to add a slot with
  *          the executionStep FIRST_WRITE. Otherwise the communication sequence will never be
@@ -21,15 +23,17 @@
  */
 class SusHandler : public DeviceHandlerBase {
  public:
+  enum ClkModes { INT_CLOCKED, EXT_CLOCKED, EXT_CLOCKED_WITH_TEMP };
+
   static const uint8_t FIRST_WRITE = 7;
 
-  SusHandler(object_id_t objectId, object_id_t comIF, CookieIF* comCookie,
+  SusHandler(object_id_t objectId, uint8_t susIdx, object_id_t comIF, CookieIF* comCookie);
-             LinuxLibgpioIF* gpioComIF, gpioId_t chipSelectId);
   virtual ~SusHandler();
 
-  virtual ReturnValue_t performOperation(uint8_t counter) override;
+  void enablePeriodicPrintout(bool enable, uint8_t divider);
 
   virtual ReturnValue_t initialize() override;
+  void setToGoToNormalMode(bool enable);
 
  protected:
   void doStartUp() override;
@@ -42,7 +46,6 @@ class SusHandler : public DeviceHandlerBase {
   ReturnValue_t scanForReply(const uint8_t* start, size_t remainingSize, DeviceCommandId_t* foundId,
                              size_t* foundLen) override;
   ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t* packet) override;
-  void setNormalDatapoolEntriesInvalid() override;
   uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
   ReturnValue_t initializeLocalDataPool(localpool::DataPool& localDataPoolMap,
                                         LocalDataPoolManager& poolManager) override;
@@ -53,19 +56,34 @@ class SusHandler : public DeviceHandlerBase {
   static const ReturnValue_t ERROR_UNLOCK_MUTEX = MAKE_RETURN_CODE(0xA0);
   static const ReturnValue_t ERROR_LOCK_MUTEX = MAKE_RETURN_CODE(0xA1);
 
-  enum class CommunicationStep { IDLE, WRITE_SETUP, START_CONVERSIONS, READ_CONVERSIONS };
+  enum class ComStates {
+    IDLE,
+    WRITE_SETUP,
+    EXT_CLOCKED_CONVERSIONS,
+    EXT_CLOCKED_TEMP,
+    START_INT_CLOCKED_CONVERSIONS,
+    READ_INT_CLOCKED_CONVERSIONS
+  };
 
-  LinuxLibgpioIF* gpioComIF = nullptr;
+  bool periodicPrintout = false;
-
+  PeriodicOperationDivider divider;
-  gpioId_t chipSelectId = gpio::NO_GPIO;
+  bool goToNormalModeImmediately = false;
+  bool commandExecuted = false;
 
   SUS::SusDataset dataset;
+  // Read temperature in each alternating communication step when using
+  // externally clocked mode
+  ClkModes clkMode = ClkModes::INT_CLOCKED;
+  PoolEntry<float> tempC = PoolEntry<float>({0.0});
+  PoolEntry<uint16_t> channelVec = PoolEntry<uint16_t>({0, 0, 0, 0, 0, 0});
 
+  uint8_t susIdx = 0;
   uint8_t cmdBuffer[SUS::MAX_CMD_SIZE];
-  CommunicationStep communicationStep = CommunicationStep::IDLE;
+  ComStates comState = ComStates::IDLE;
 
   MutexIF::TimeoutType timeoutType = MutexIF::TimeoutType::WAITING;
   uint32_t timeoutMs = 20;
+  void printDataset();
 
   MutexIF* spiMutex = nullptr;
 };

mission/devices/devicedefinitions/SusDefinitions.h

@@ -8,25 +8,23 @@
 
 namespace SUS {
 
-/**
- * Some MAX1227 could not be reached with frequencies around 4 MHz. Maybe this is caused by
- * the decoder and buffer circuits. Thus frequency is here defined to 1 MHz.
- */
-static const uint32_t MAX1227_SPI_FREQ = 1000000;
-
 static const DeviceCommandId_t NONE = 0x0;  // Set when no command is pending
 
-static const DeviceCommandId_t WRITE_SETUP = 0x1;
+static const DeviceCommandId_t WRITE_SETUP = 1;
 /**
  * This command initiates the ADC conversion for all channels including the internal
  * temperature sensor.
  */
-static const DeviceCommandId_t START_CONVERSIONS = 0x2;
+static const DeviceCommandId_t START_INT_TIMED_CONVERSIONS = 2;
 /**
  * This command reads the internal fifo which holds the temperature and the channel
  * conversions.
  */
-static const DeviceCommandId_t READ_CONVERSIONS = 0x3;
+static constexpr DeviceCommandId_t READ_INT_TIMED_CONVERSIONS = 3;
+
+static constexpr DeviceCommandId_t READ_EXT_TIMED_CONVERSIONS = 4;
+
+static constexpr DeviceCommandId_t READ_EXT_TIMED_TEMPS = 5;
 
 /**
  * @brief   This is the configuration byte which will be written to the setup register after
@@ -39,7 +37,8 @@ static const DeviceCommandId_t READ_CONVERSIONS = 0x3;
  *                                                written to the setup register
  *
  */
-static const uint8_t SETUP = 0b01101000;
+static constexpr uint8_t SETUP_INT_CLOKED = 0b01101000;
+static constexpr uint8_t SETUP_EXT_CLOCKED = 0b01111000;
 
 /**
  * @brief This values will always be written to the ADC conversion register to specify the
@@ -51,24 +50,18 @@ static const uint8_t SETUP = 0b01101000;
  */
 static const uint8_t CONVERSION = 0b10101001;
 
-static const uint8_t SUS_DATA_SET_ID = READ_CONVERSIONS;
+static const uint8_t SUS_DATA_SET_ID = READ_INT_TIMED_CONVERSIONS;
 
 /** Size of data replies. Temperature and 6 channel convesions (AIN0 - AIN5) */
-static const uint8_t SIZE_READ_CONVERSIONS = 14;
+static const uint8_t SIZE_READ_INT_CONVERSIONS = 14;
+// 6 * conv byte, 6 * 0 and one trailing zero
+static constexpr uint8_t SIZE_READ_EXT_CONVERSIONS = 13;
 
-static const uint8_t MAX_CMD_SIZE = SIZE_READ_CONVERSIONS;
+static const uint8_t MAX_CMD_SIZE = 32;
 
 static const uint8_t POOL_ENTRIES = 7;
 
-enum Max1227PoolIds : lp_id_t {
+enum Max1227PoolIds : lp_id_t { TEMPERATURE_C, CHANNEL_VEC };
-  TEMPERATURE_C,
-  AIN0,
-  AIN1,
-  AIN2,
-  AIN3,
-  AIN4,
-  AIN5,
-};
 
 class SusDataset : public StaticLocalDataSet<POOL_ENTRIES> {
  public:
@@ -77,12 +70,7 @@ class SusDataset : public StaticLocalDataSet<POOL_ENTRIES> {
   SusDataset(object_id_t objectId) : StaticLocalDataSet(sid_t(objectId, SUS_DATA_SET_ID)) {}
 
   lp_var_t<float> temperatureCelcius = lp_var_t<float>(sid.objectId, TEMPERATURE_C, this);
-  lp_var_t<uint16_t> ain0 = lp_var_t<uint16_t>(sid.objectId, AIN0, this);
+  lp_vec_t<uint16_t, 6> channels = lp_vec_t<uint16_t, 6>(sid.objectId, CHANNEL_VEC, this);
-  lp_var_t<uint16_t> ain1 = lp_var_t<uint16_t>(sid.objectId, AIN1, this);
-  lp_var_t<uint16_t> ain2 = lp_var_t<uint16_t>(sid.objectId, AIN2, this);
-  lp_var_t<uint16_t> ain3 = lp_var_t<uint16_t>(sid.objectId, AIN3, this);
-  lp_var_t<uint16_t> ain4 = lp_var_t<uint16_t>(sid.objectId, AIN4, this);
-  lp_var_t<uint16_t> ain5 = lp_var_t<uint16_t>(sid.objectId, AIN5, this);
 };
 }  // namespace SUS
 

mission/devices/max1227.cpp

@@ -0,0 +1,28 @@
+#include "max1227.h"
+
+#include <cstring>
+
+void max1227::prepareExternallyClockedSingleChannelRead(uint8_t *spiBuf, uint8_t channel,
+                                                        size_t &sz) {
+  spiBuf[0] = buildConvByte(ScanModes::N_ONCE, channel, false);
+  spiBuf[1] = 0x00;
+  spiBuf[2] = 0x00;
+  sz = 3;
+}
+
+void max1227::prepareExternallyClockedRead0ToN(uint8_t *spiBuf, uint8_t n, size_t &sz) {
+  for (uint8_t idx = 0; idx <= n; idx++) {
+    spiBuf[idx * 2] = buildConvByte(ScanModes::N_ONCE, idx, false);
+    spiBuf[idx * 2 + 1] = 0x00;
+  }
+  spiBuf[(n + 1) * 2] = 0x00;
+  sz += (n + 1) * 2 + 1;
+}
+
+void max1227::prepareExternallyClockedTemperatureRead(uint8_t *spiBuf, size_t &sz) {
+  spiBuf[0] = buildConvByte(ScanModes::N_ONCE, 0, true);
+  std::memset(spiBuf + 1, 0, 24);
+  sz += 25;
+}
+
+float max1227::getTemperature(int16_t temp) { return static_cast<float>(temp) * 0.125; }

mission/devices/max1227.h

@@ -0,0 +1,84 @@
+#ifndef MISSION_DEVICES_MAX1227_H_
+#define MISSION_DEVICES_MAX1227_H_
+
+#include <cstddef>
+#include <cstdint>
+
+namespace max1227 {
+
+enum ScanModes : uint8_t {
+  CHANNELS_0_TO_N = 0b00,
+  CHANNEL_N_TO_HIGHEST = 0b01,
+  N_REPEATEDLY = 0b10,
+  N_ONCE = 0b11
+};
+
+enum ClkSel : uint8_t {
+  INT_CONV_INT_TIMED_CNVST_AS_CNVST = 0b00,
+  INT_CONV_EXT_TIMED_CNVST = 0b01,
+  // Default mode upon power-up
+  INT_CONV_INT_TIMED_CNVST_AS_AIN = 0b10,
+  // Use external SPI clock for conversion and timing
+  EXT_CONV_EXT_TIMED = 0b11
+};
+
+enum RefSel : uint8_t {
+  INT_REF_WITH_WAKEUP = 0b00,
+  // No wakeup delay needed
+  EXT_REF_SINGLE_ENDED = 0b01,
+  INT_REF_NO_WAKEUP = 0b10,
+  // No wakeup delay needed
+  EXT_REF_DIFFERENTIAL = 0b11
+};
+
+enum DiffSel : uint8_t {
+  NONE_0 = 0b00,
+  NONE_1 = 0b01,
+  // One unipolar config byte follows the setup byte
+  UNIPOLAR_CFG = 0b10,
+  // One bipolar config byte follows the setup byte
+  BIPOLAR_CFG = 0b11
+};
+
+constexpr uint8_t buildResetByte(bool fifoOnly) { return (1 << 4) | (fifoOnly << 3); }
+
+constexpr uint8_t buildConvByte(ScanModes scanMode, uint8_t channel, bool readTemp) {
+  return (1 << 7) | (channel << 3) | (scanMode << 1) | readTemp;
+}
+
+constexpr uint8_t buildSetupByte(ClkSel clkSel, RefSel refSel, DiffSel diffSel) {
+  return (1 << 6) | (clkSel << 4) | (refSel << 2) | diffSel;
+}
+
+/**
+ * If there is a wakeup delay, there needs to be a 65 us delay between sending
+ * the first byte (conversion byte) and the the rest of the SPI buffer.
+ * The raw ADC value will be located in the first and second reply byte.
+ * @param spiBuf
+ * @param n
+ * @param sz
+ */
+void prepareExternallyClockedSingleChannelRead(uint8_t* spiBuf, uint8_t channel, size_t& sz);
+
+/**
+ * If there is a wakeup delay, there needs to be a 65 us delay between sending
+ * the first byte (first conversion byte) the the rest of the SPI buffer.
+ * @param spiBuf
+ * @param n Channel number. Example: If the ADC has 6 channels, n will be 5
+ * @param sz
+ */
+void prepareExternallyClockedRead0ToN(uint8_t* spiBuf, uint8_t n, size_t& sz);
+
+/**
+ * Prepare an externally clocked temperature read. 25 bytes have to be sent
+ * and the raw temperature value will appear on the last 2 bytes of the reply.
+ * @param spiBuf
+ * @param sz
+ */
+void prepareExternallyClockedTemperatureRead(uint8_t* spiBuf, size_t& sz);
+
+float getTemperature(int16_t temp);
+
+}  // namespace max1227
+
+#endif /* MISSION_DEVICES_MAX1227_H_ */

mission/tmtc/CCSDSHandler.cpp

@@ -23,7 +23,9 @@ CCSDSHandler::CCSDSHandler(object_id_t objectId, object_id_t ptmeId, object_id_t
       enTxClock(enTxClock),
       enTxData(enTxData) {
   commandQueue = QueueFactory::instance()->createMessageQueue(QUEUE_SIZE);
-  eventQueue = QueueFactory::instance()->createMessageQueue(EventMessage::EVENT_MESSAGE_SIZE * 2);
+  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
+  eventQueue =
+      QueueFactory::instance()->createMessageQueue(10, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
 }
 
 CCSDSHandler::~CCSDSHandler() {}

mission/tmtc/CCSDSHandler.h

@@ -132,7 +132,7 @@ class CCSDSHandler : public SystemObject,
 
   ActionHelper actionHelper;
 
-  MessageQueueId_t tcDistributorQueueId;
+  MessageQueueId_t tcDistributorQueueId = MessageQueueIF::NO_QUEUE;
 
   PtmeConfig* ptmeConfig = nullptr;
 

mission/tmtc/VirtualChannel.cpp

@@ -7,9 +7,11 @@
 #include "fsfw/serviceinterface/ServiceInterfaceStream.h"
 #include "fsfw/tmtcservices/TmTcMessage.h"
 
-VirtualChannel::VirtualChannel(uint8_t vcId, uint32_t tmQueueDepth) : vcId(vcId) {
+VirtualChannel::VirtualChannel(uint8_t vcId, uint32_t tmQueueDepth, object_id_t ownerId)
-  tmQueue = QueueFactory::instance()->createMessageQueue(tmQueueDepth,
+    : vcId(vcId) {
-                                                         MessageQueueMessage::MAX_MESSAGE_SIZE);
+  auto mqArgs = MqArgs(ownerId, reinterpret_cast<void*>(vcId));
+  tmQueue = QueueFactory::instance()->createMessageQueue(
+      tmQueueDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 ReturnValue_t VirtualChannel::initialize() {

mission/tmtc/VirtualChannel.h

@@ -24,7 +24,7 @@ class VirtualChannel : public AcceptsTelemetryIF, public HasReturnvaluesIF {
    * @param vcId  The virtual channel id assigned to this object
    * @param tmQueueDepth  Queue depth of queue receiving telemetry from other objects
    */
-  VirtualChannel(uint8_t vcId, uint32_t tmQueueDepth);
+  VirtualChannel(uint8_t vcId, uint32_t tmQueueDepth, object_id_t ownerId);
 
   ReturnValue_t initialize();
   MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) override;

mission/utility/TmFunnel.cpp

@@ -11,10 +11,11 @@ object_id_t TmFunnel::storageDestination = objects::NO_OBJECT;
 
 TmFunnel::TmFunnel(object_id_t objectId, uint32_t messageDepth)
     : SystemObject(objectId), messageDepth(messageDepth) {
-  tmQueue = QueueFactory::instance()->createMessageQueue(messageDepth,
+  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
-                                                         MessageQueueMessage::MAX_MESSAGE_SIZE);
+  tmQueue = QueueFactory::instance()->createMessageQueue(
+      messageDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
   storageQueue = QueueFactory::instance()->createMessageQueue(
-      messageDepth, MessageQueueMessage::MAX_MESSAGE_SIZE);
+      messageDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
 }
 
 TmFunnel::~TmFunnel() {}

watchdog/CMakeLists.txt

@@ -2,3 +2,7 @@ target_sources(${WATCHDOG_NAME} PRIVATE
     main.cpp
     Watchdog.cpp
 )
+
+target_include_directories(${WATCHDOG_NAME} PRIVATE
+    ${CMAKE_CURRENT_SOURCE_DIR}
+)

watchdog/definitions.h

@@ -0,0 +1,19 @@
+#ifndef WATCHDOG_DEFINITIONS_H_
+#define WATCHDOG_DEFINITIONS_H_
+
+namespace watchdog {
+
+// Suspend watchdog operations temporarily
+static constexpr char SUSPEND_CHAR = 's';
+// Resume watchdog operations
+static constexpr char RESTART_CHAR = 'b';
+// Causes the watchdog to close down
+static constexpr char CANCEL_CHAR = 'c';
+
+static constexpr int TIMEOUT_MS = 5 * 1000;
+const std::string FIFO_NAME = "/tmp/watchdog-pipe";
+const std::string RUNNING_FILE_NAME = "/tmp/obsw-running";
+
+}
+
+#endif /* WATCHDOG_DEFINITIONS_H_ */

watchdog/watchdogConf.h.in

@@ -1,24 +1,11 @@
 #include <cstdint>
 #include <string>
 
+#include "watchdog/definitions.h"
+
 #define WATCHDOG_VERBOSE_LEVEL              1
 /**
  * This flag instructs the watchdog to create a special file in /tmp if the OBSW is running
  * or to delete it if it is not running
  */
 #define WATCHDOG_CREATE_FILE_IF_RUNNING     1
-
-namespace watchdog {
-
-static constexpr int TIMEOUT_MS = 5 * 1000;
-const std::string FIFO_NAME = "/tmp/watchdog-pipe";
-const std::string RUNNING_FILE_NAME = "/tmp/obsw-running";
-
-// Suspend watchdog operations temporarily
-static constexpr char SUSPEND_CHAR = 's';
-// Resume watchdog operations
-static constexpr char RESTART_CHAR = 'b';
-// Causes the watchdog to close down
-static constexpr char CANCEL_CHAR = 'c';
-
-}