Merge remote-tracking branch 'origin/develop' into mueller/plpcdu-refactoring

2022-03-29 15:40:02 +02:00
parent 6fa975cc74 2b8728fcd8
commit b5363604bc
84 changed files with 3529 additions and 1500 deletions
--- a/bsp_q7s/core/InitMission.cpp
+++ b/bsp_q7s/core/InitMission.cpp
@ -55,14 +55,12 @@ void initmission::initTasks() {
  void (*missedDeadlineFunc)(void) = nullptr;
 #endif

-#if BOARD_TE0720 == 0
  PeriodicTaskIF* coreController = factory->createPeriodicTask(
      "CORE_CTRL", 60, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.4, missedDeadlineFunc);
  result = coreController->addComponent(objects::CORE_CONTROLLER);
  if (result != HasReturnvaluesIF::RETURN_OK) {
    initmission::printAddObjectError("CORE_CTRL", objects::CORE_CONTROLLER);
  }
-#endif

  /* TMTC Distribution */
  PeriodicTaskIF* tmTcDistributor = factory->createPeriodicTask(
@ -140,7 +138,6 @@ void initmission::initTasks() {
    initmission::printAddObjectError("TCS_BOARD_ASS", objects::TCS_BOARD_ASS);
  }

-#if BOARD_TE0720 == 0
  // FS task, task interval does not matter because it runs in permanent loop, priority low
  // because it is a non-essential background task
  PeriodicTaskIF* fsTask = factory->createPeriodicTask(
@ -159,7 +156,14 @@ void initmission::initTasks() {
  }
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */

-#endif /* BOARD_TE0720 */
+#if OBSW_ADD_PLOC_MPSOC == 1
+  PeriodicTaskIF* mpsocHelperTask = factory->createPeriodicTask(
+      "PLOC_MPSOC_HELPER", 20, PeriodicTaskIF::MINIMUM_STACK_SIZE, 0.2, missedDeadlineFunc);
+  result = mpsocHelperTask->addComponent(objects::PLOC_MPSOC_HELPER);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    initmission::printAddObjectError("PLOC_MPSOC_HELPER", objects::PLOC_MPSOC_HELPER);
+  }
+#endif /* OBSW_ADD_PLOC_MPSOC */

 #if OBSW_TEST_CCSDS_BRIDGE == 1
  PeriodicTaskIF* ptmeTestTask = factory->createPeriodicTask(
@ -203,9 +207,7 @@ void initmission::initTasks() {
  pdecHandlerTask->startTask();
 #endif /* OBSW_USE_CCSDS_IP_CORE == 1 */

-#if BOARD_TE0720 == 0
  coreController->startTask();
-#endif

  taskStarter(pstTasks, "PST task vector");
  taskStarter(pusTasks, "PUS task vector");
@ -217,12 +219,10 @@ void initmission::initTasks() {
  ptmeTestTask->startTask();
 #endif

-#if BOARD_TE0720 == 0
  fsTask->startTask();
 #if OBSW_ADD_STAR_TRACKER == 1
-  strHelperTask > startTask();
+  strHelperTask->startTask();
 #endif /* OBSW_ADD_STAR_TRACKER == 1 */
-#endif

 #if OBSW_ADD_ACS_HANDLERS == 1
  acsTask->startTask();
@ -236,7 +236,6 @@ void initmission::createPstTasks(TaskFactory& factory,
                                 TaskDeadlineMissedFunction missedDeadlineFunc,
                                 std::vector<PeriodicTaskIF*>& taskVec) {
  ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-#if BOARD_TE0720 == 0
  /* Polling Sequence Table Default */
 #if OBSW_ADD_SPI_TEST_CODE == 0
  FixedTimeslotTaskIF* spiPst = factory.createFixedTimeslotTask(
@ -302,15 +301,6 @@ void initmission::createPstTasks(TaskFactory& factory,
    }
  }
  taskVec.push_back(gomSpacePstTask);
-#else  /* BOARD_TE7020 == 0 */
-  FixedTimeslotTaskIF* pollingSequenceTaskTE0720 = factory.createFixedTimeslotTask(
-      "PST_TASK_TE0720", 30, PeriodicTaskIF::MINIMUM_STACK_SIZE * 8, 3.0, missedDeadlineFunc);
-  result = pst::pollingSequenceTE0720(pollingSequenceTaskTE0720);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    sif::error << "InitMission::initTasks: Creating TE0720 PST failed!" << std::endl;
-  }
-  taskVec.push_back(pollingSequenceTaskTE0720);
-#endif /* BOARD_TE7020 == 1 */
 }

 void initmission::createPusTasks(TaskFactory& factory,
@ -417,12 +407,6 @@ void initmission::createTestTasks(TaskFactory& factory,
  }
 #endif

-#if BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1
-  result = testTask->addComponent(objects::LIBGPIOD_TEST);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-    initmission::printAddObjectError("GPIOD_TEST", objects::LIBGPIOD_TEST);
-  }
-#endif /* BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1 */
  taskVec.push_back(testTask);

 #endif  // OBSW_ADD_TEST_TASK == 1 && OBSW_ADD_TEST_CODE == 1
--- a/bsp_q7s/core/ObjectFactory.cpp
+++ b/bsp_q7s/core/ObjectFactory.cpp
@ -19,9 +19,6 @@
 #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/memory/FileSystemHandler.h"
 #include "busConf.h"
 #include "ccsdsConfig.h"
@ -35,7 +32,13 @@
 #include "linux/csp/CspComIF.h"
 #include "linux/csp/CspCookie.h"
 #include "linux/devices/GPSHyperionLinuxController.h"
+#include "linux/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #include "linux/devices/devicedefinitions/StarTrackerDefinitions.h"
+#include "linux/devices/ploc/PlocMPSoCHandler.h"
+#include "linux/devices/ploc/PlocMPSoCHelper.h"
+#include "linux/devices/ploc/PlocMemoryDumper.h"
+#include "linux/devices/ploc/PlocSupervisorHandler.h"
+#include "linux/devices/ploc/PlocUpdater.h"
 #include "linux/devices/startracker/StarTrackerHandler.h"
 #include "linux/devices/startracker/StrHelper.h"
 #include "tmtc/apid.h"
@ -52,6 +55,7 @@
 #include "fsfw/tmtcservices/CommandingServiceBase.h"
 #include "fsfw/tmtcservices/PusServiceBase.h"
 #include "fsfw_hal/common/gpio/GpioCookie.h"
+#include "fsfw_hal/common/gpio/gpioDefinitions.h"
 #include "fsfw_hal/devicehandlers/GyroL3GD20Handler.h"
 #include "fsfw_hal/devicehandlers/MgmLIS3MDLHandler.h"
 #include "fsfw_hal/devicehandlers/MgmRM3100Handler.h"
@ -74,7 +78,6 @@
 #include "mission/devices/PDU1Handler.h"
 #include "mission/devices/PDU2Handler.h"
 #include "mission/devices/PayloadPcduHandler.h"
-#include "mission/devices/PlocMPSoCHandler.h"
 #include "mission/devices/RadiationSensorHandler.h"
 #include "mission/devices/RwHandler.h"
 #include "mission/devices/SolarArrayDeploymentHandler.h"
@ -83,7 +86,6 @@
 #include "mission/devices/Tmp1075Handler.h"
 #include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
 #include "mission/devices/devicedefinitions/Max31865Definitions.h"
-#include "mission/devices/devicedefinitions/PlocMPSoCDefinitions.h"
 #include "mission/devices/devicedefinitions/RadSensorDefinitions.h"
 #include "mission/devices/devicedefinitions/RwDefinitions.h"
 #include "mission/devices/devicedefinitions/SusDefinitions.h"
@ -106,8 +108,8 @@ void Factory::setStaticFrameworkObjectIds() {
  CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
  CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;

-  // DeviceHandlerBase::powerSwitcherId = objects::PCDU_HANDLER;
-  DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;
+  DeviceHandlerBase::powerSwitcherId = objects::PCDU_HANDLER;
+  //  DeviceHandlerBase::powerSwitcherId = objects::NO_OBJECT;

 #if OBSW_TM_TO_PTME == 1
  TmFunnel::downlinkDestination = objects::CCSDS_HANDLER;
@ -134,7 +136,6 @@ void ObjectFactory::produce(void* args) {
  PowerSwitchIF* pwrSwitcher = nullptr;
  createCommunicationInterfaces(&gpioComIF, &uartComIF, &spiComIF, &i2cComIF);
  createTmpComponents();
-#if BOARD_TE0720 == 0
  new CoreController(objects::CORE_CONTROLLER);

  gpioCallbacks::disableAllDecoder();
@ -153,6 +154,7 @@ void ObjectFactory::produce(void* args) {
  createSyrlinksComponents();
 #endif /* OBSW_ADD_SYRLINKS == 1 */
  createRtdComponents(gpioComIF, pwrSwitcher);
+  createPayloadComponents(gpioComIF);

 #if OBSW_ADD_MGT == 1
  I2cCookie* imtqI2cCookie =
@ -180,29 +182,12 @@ void ObjectFactory::produce(void* args) {
 #endif
 #endif

-#if OBSW_ADD_PLOC_MPSOC == 1
-  UartCookie* plocMpsocCookie =
-      new UartCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV,
-                     UartModes::NON_CANONICAL, uart::PLOC_MPSOC_BAUD, PLOC_MPSOC::MAX_REPLY_SIZE);
-  new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, plocMpsocCookie);
-#endif /* OBSW_ADD_PLOC_MPSOC == 1 */
-
-#if OBSW_ADD_PLOC_SUPERVISOR == 1
-  UartCookie* plocSupervisorCookie = new UartCookie(
-      objects::PLOC_SUPERVISOR_HANDLER, q7s::UART_PLOC_SUPERVSIOR_DEV, UartModes::NON_CANONICAL,
-      uart::PLOC_SUPERVISOR_BAUD, PLOC_SPV::MAX_PACKET_SIZE * 20);
-  plocSupervisorCookie->setNoFixedSizeReply();
-  PlocSupervisorHandler* plocSupervisor = new PlocSupervisorHandler(
-      objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, plocSupervisorCookie);
-  plocSupervisor->setStartUpImmediately();
-#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
-
  new FileSystemHandler(objects::FILE_SYSTEM_HANDLER);

 #if OBSW_ADD_STAR_TRACKER == 1
  UartCookie* starTrackerCookie =
      new UartCookie(objects::STAR_TRACKER, q7s::UART_STAR_TRACKER_DEV, UartModes::NON_CANONICAL,
-                     uart::STAR_TRACKER_BAUD, StarTracker::MAX_FRAME_SIZE * 2 + 2);
+                     uart::STAR_TRACKER_BAUD, startracker::MAX_FRAME_SIZE * 2 + 2);
  starTrackerCookie->setNoFixedSizeReply();
  StrHelper* strHelper = new StrHelper(objects::STR_HELPER);
  StarTrackerHandler* starTrackerHandler = new StarTrackerHandler(
@ -211,8 +196,6 @@ void ObjectFactory::produce(void* args) {

 #endif /* OBSW_ADD_STAR_TRACKER == 1 */

-#endif /* TE7020 == 0 */
-
 #if OBSW_USE_CCSDS_IP_CORE == 1
  createCcsdsComponents(gpioComIF);
 #endif /* OBSW_USE_CCSDS_IP_CORE == 1 */
@ -227,17 +210,10 @@ void ObjectFactory::produce(void* args) {
 }

 void ObjectFactory::createTmpComponents() {
-#if BOARD_TE0720 == 1
-  I2cCookie* i2cCookieTmp1075tcs1 =
-      new I2cCookie(addresses::TMP1075_TCS_1, TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-0"));
-  I2cCookie* i2cCookieTmp1075tcs2 =
-      new I2cCookie(addresses::TMP1075_TCS_2, TMP1075::MAX_REPLY_LENGTH, std::string("/dev/i2c-0"));
-#else
  I2cCookie* i2cCookieTmp1075tcs1 =
      new I2cCookie(addresses::TMP1075_TCS_1, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV);
  I2cCookie* i2cCookieTmp1075tcs2 =
      new I2cCookie(addresses::TMP1075_TCS_2, TMP1075::MAX_REPLY_LENGTH, q7s::I2C_DEFAULT_DEV);
-#endif

  /* Temperature sensors */
  Tmp1075Handler* tmp1075Handler_1 =
@ -262,10 +238,8 @@ void ObjectFactory::createCommunicationInterfaces(LinuxLibgpioIF** gpioComIF, Ua
  *uartComIF = new UartComIF(objects::UART_COM_IF);
  *spiComIF = new SpiComIF(objects::SPI_COM_IF, *gpioComIF);

-#if BOARD_TE0720 == 0
  /* Adding gpios for chip select decoding to the gpioComIf */
  gpioCallbacks::initSpiCsDecoder(*gpioComIF);
-#endif
 }

 void ObjectFactory::createPcduComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF** pwrSwitcher) {
@ -936,6 +910,44 @@ void ObjectFactory::createRtdComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF
 #endif  // OBSW_ADD_RTD_DEVICES == 1
 }

+void ObjectFactory::createPayloadComponents(LinuxLibgpioIF* gpioComIF) {
+  using namespace gpio;
+  std::stringstream consumer;
+#if OBSW_ADD_PLOC_MPSOC == 1
+  consumer << "0x" << std::hex << objects::PLOC_MPSOC_HANDLER;
+  auto gpioConfigMPSoC = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_MPSOC_UART,
+                                                    consumer.str(), Direction::OUT, Levels::HIGH);
+  auto mpsocGpioCookie = new GpioCookie;
+  mpsocGpioCookie->addGpio(gpioIds::ENABLE_MPSOC_UART, gpioConfigMPSoC);
+  gpioComIF->addGpios(mpsocGpioCookie);
+  auto mpsocCookie =
+      new UartCookie(objects::PLOC_MPSOC_HANDLER, q7s::UART_PLOC_MPSOC_DEV,
+                     UartModes::NON_CANONICAL, uart::PLOC_MPSOC_BAUD, mpsoc::MAX_REPLY_SIZE);
+  mpsocCookie->setNoFixedSizeReply();
+  auto plocMpsocHelper = new PlocMPSoCHelper(objects::PLOC_MPSOC_HELPER);
+  auto plocMPSoC =
+      new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, mpsocCookie,
+                           plocMpsocHelper, Gpio(gpioIds::ENABLE_MPSOC_UART, gpioComIF));
+  plocMPSoC->setStartUpImmediately();
+#endif /* OBSW_ADD_PLOC_MPSOC == 1 */
+
+#if OBSW_ADD_PLOC_SUPERVISOR == 1
+  consumer << "0x" << std::hex << objects::PLOC_SUPERVISOR_HANDLER;
+  auto gpioConfigSupv = new GpiodRegularByLineName(q7s::gpioNames::ENABLE_SUPV_UART, consumer.str(),
+                                                   Direction::OUT, Levels::HIGH);
+  auto supvGpioCookie = new GpioCookie;
+  supvGpioCookie->addGpio(gpioIds::ENABLE_SUPV_UART, gpioConfigSupv);
+  gpioComIF->addGpios(supvGpioCookie);
+  auto supervisorCookie = new UartCookie(
+      objects::PLOC_SUPERVISOR_HANDLER, q7s::UART_PLOC_SUPERVSIOR_DEV, UartModes::NON_CANONICAL,
+      uart::PLOC_SUPERVISOR_BAUD, PLOC_SPV::MAX_PACKET_SIZE * 20);
+  supervisorCookie->setNoFixedSizeReply();
+  new PlocSupervisorHandler(objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF,
+                            supervisorCookie, Gpio(gpioIds::ENABLE_SUPV_UART, gpioComIF));
+#endif /* OBSW_ADD_PLOC_SUPERVISOR == 1 */
+  static_cast<void>(consumer);
+}
+
 void ObjectFactory::createReactionWheelComponents(LinuxLibgpioIF* gpioComIF) {
  using namespace gpio;
  GpioCookie* gpioCookieRw = new GpioCookie;
@ -1120,7 +1132,6 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
  new PdecHandler(objects::PDEC_HANDLER, objects::CCSDS_HANDLER, gpioComIF, gpioIds::PDEC_RESET,
                  q7s::UIO_PDEC_CONFIG_MEMORY, q7s::UIO_PDEC_RAM, q7s::UIO_PDEC_REGISTERS);

-#if BOARD_TE0720 == 0
  GpioCookie* gpioRS485Chip = new GpioCookie;
  gpio = new GpiodRegularByLineName(q7s::gpioNames::RS485_EN_TX_CLOCK, "RS485 Transceiver",
                                    Direction::OUT, Levels::LOW);
@ -1138,7 +1149,6 @@ void ObjectFactory::createCcsdsComponents(LinuxLibgpioIF* gpioComIF) {
  gpioRS485Chip->addGpio(gpioIds::RS485_EN_RX_DATA, gpio);

  gpioComIF->addGpios(gpioRS485Chip);
-#endif /* BOARD_TE0720 == 0 */
 }

 void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF* spiComIF,
@ -1193,112 +1203,19 @@ void ObjectFactory::createPlPcduComponents(LinuxLibgpioIF* gpioComIF, SpiComIF*
      pwrSwitcher, pcduSwitches::Switches::PDU2_CH1_PL_PCDU_BATT_0_14V8,
      pcduSwitches::Switches::PDU2_CH6_PL_PCDU_BATT_1_14V8, false);
  spiCookie->setCallbackMode(PayloadPcduHandler::extConvAsTwoCallback, plPcduHandler);
-  static_cast<void>(plPcduHandler);
+//  plPcduHandler->enablePeriodicPrintout(true, 5);
+//  static_cast<void>(plPcduHandler);
 #if OBSW_TEST_PL_PCDU == 1
  plPcduHandler->setStartUpImmediately();
 #endif
 #if OBSW_DEBUG_PL_PCDU == 1
  plPcduHandler->setToGoToNormalModeImmediately(true);
-  plPcduHandler->enablePeriodicPrintout(true, 5);
+  plPcduHandler->enablePeriodicPrintout(true, 10);
 #endif
 }

 void ObjectFactory::createTestComponents(LinuxLibgpioIF* gpioComIF) {
-#if BOARD_TE0720 == 0
  new Q7STestTask(objects::TEST_TASK);
-#endif
-
-#if BOARD_TE0720 == 1 && OBSW_TEST_LIBGPIOD == 1
-#if OBSW_TEST_GPIO_OPEN_BYLABEL == 1
-  /* Configure MIO0 as input */
-  GpiodRegular* testGpio = new GpiodRegular("MIO0", Direction::OUT, 0, "/amba_pl/gpio@41200000", 0);
-#elif OBSW_TEST_GPIO_OPEN_BY_LINE_NAME
-  GpiodRegularByLineName* testGpio =
-      new GpiodRegularByLineName("test-name", "gpio-test", Direction::OUT, 0);
-#else
-  /* Configure MIO0 as input */
-  GpiodRegular* testGpio = new GpiodRegular("gpiochip0", 0, "MIO0", gpio::IN, 0);
-#endif /* OBSW_TEST_GPIO_LABEL == 1 */
-  GpioCookie* gpioCookie = new GpioCookie;
-  gpioCookie->addGpio(gpioIds::TEST_ID_0, testGpio);
-  new LibgpiodTest(objects::LIBGPIOD_TEST, objects::GPIO_IF, gpioCookie);
-#endif
-
-#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"), Direction::OUT, 1);
-  gpioCookieSus->addGpio(gpioIds::CS_SUS_0, chipSelectSus);
-  gpioComIF->addGpios(gpioCookieSus);
-
-  SpiCookie* spiCookieSus =
-      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_0, objects::SPI_COM_IF, spiCookieSus, gpioComIF, gpioIds::CS_SUS_0);
-#endif
-
-#if BOARD_TE0720 == 1 && OBSW_TEST_CCSDS_BRIDGE == 1
-  GpioCookie* gpioCookieCcsdsIp = new GpioCookie;
-  GpiodRegular* papbBusyN =
-      new GpiodRegular(std::string("gpiochip0"), 0, std::string("PAPBBusy_VC0"));
-  gpioCookieCcsdsIp->addGpio(gpioIds::PAPB_BUSY_N, papbBusyN);
-  GpiodRegular* papbEmpty =
-      new GpiodRegular(std::string("gpiochip0"), 1, std::string("PAPBEmpty_VC0"));
-  gpioCookieCcsdsIp->addGpio(gpioIds::PAPB_EMPTY, papbEmpty);
-  gpioComIF->addGpios(gpioCookieCcsdsIp);
-
-  new CCSDSIPCoreBridge(objects::CCSDS_IP_CORE_BRIDGE, objects::CCSDS_PACKET_DISTRIBUTOR,
-                        objects::TM_STORE, objects::TC_STORE, gpioComIF, std::string("/dev/uio0"),
-                        gpioIds::PAPB_BUSY_N, gpioIds::PAPB_EMPTY);
-#endif
-
-#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"), Direction::OUT, 1);
-  gpioCookieRadSensor->addGpio(gpioIds::CS_RAD_SENSOR, chipSelectRadSensor);
-  gpioComIF->addGpios(gpioCookieRadSensor);
-
-  SpiCookie* spiCookieRadSensor =
-      new SpiCookie(addresses::RAD_SENSOR, gpioIds::CS_RAD_SENSOR, std::string("/dev/spidev1.0"),
-                    SUS::MAX_CMD_SIZE, spi::DEFAULT_MAX_1227_MODE, spi::DEFAULT_MAX_1227_SPEED);
-
-  RadiationSensorHandler* radSensor =
-      new RadiationSensorHandler(objects::RAD_SENSOR, objects::SPI_COM_IF, spiCookieRadSensor);
-  radSensor->setStartUpImmediately();
-#endif
-
-#if BOARD_TE0720 == 1 && OBSW_ADD_PLOC_MPSOC == 1
-  UartCookie* plocUartCookie =
-      new UartCookie(std::string("/dev/ttyPS1"), 115200, PLOC_MPSOC::MAX_REPLY_SIZE);
-  /* Testing PlocMPSoCHandler on TE0720-03-1CFA */
-  PlocMPSoCHandler* mpsocPlocHandler =
-      new PlocMPSoCHandler(objects::PLOC_MPSOC_HANDLER, objects::UART_COM_IF, plocUartCookie);
-  mpsocPlocHandler->setStartUpImmediately();
-#endif
-
-#if BOARD_TE0720 == 1 && OBSW_TEST_TE7020_HEATER == 1
-  /* Configuration for MIO0 on TE0720-03-1CFA */
-  GpiodRegular* heaterGpio =
-      new GpiodRegular(std::string("gpiochip0"), 0, std::string("MIO0"), gpio::IN, 0);
-  GpioCookie* gpioCookie = new GpioCookie;
-  gpioCookie->addGpio(gpioIds::HEATER_0, heaterGpio);
-  new HeaterHandler(objects::HEATER_HANDLER, objects::GPIO_IF, gpioCookie, objects::PCDU_HANDLER,
-                    pcduSwitches::TCS_BOARD_8V_HEATER_IN);
-#endif
-
-#if BOARD_TE0720 == 1 && OBSW_ADD_PLOC_SUPERVISOR == 1
-  /* Configuration for MIO0 on TE0720-03-1CFA */
-  UartCookie* plocSupervisorCookie =
-      new UartCookie(objects::PLOC_SUPERVISOR_HANDLER, std::string("/dev/ttyPS1"),
-                     UartModes::NON_CANONICAL, 115200, PLOC_SPV::MAX_PACKET_SIZE * 20);
-  plocSupervisorCookie->setNoFixedSizeReply();
-  PlocSupervisorHandler* plocSupervisor = new PlocSupervisorHandler(
-      objects::PLOC_SUPERVISOR_HANDLER, objects::UART_COM_IF, plocSupervisorCookie);
-  plocSupervisor->setStartUpImmediately();
-#endif
-
 #if OBSW_ADD_SPI_TEST_CODE == 1
  new SpiTestClass(objects::SPI_TEST, gpioComIF);
 #endif
--- a/bsp_q7s/core/ObjectFactory.h
+++ b/bsp_q7s/core/ObjectFactory.h
@ -27,6 +27,7 @@ void createHeaterComponents();
 void createSolarArrayDeploymentComponents();
 void createSyrlinksComponents();
 void createRtdComponents(LinuxLibgpioIF* gpioComIF, PowerSwitchIF* pwrSwitcher);
+void createPayloadComponents(LinuxLibgpioIF* gpioComIF);
 void createReactionWheelComponents(LinuxLibgpioIF* gpioComIF);
 void createCcsdsComponents(LinuxLibgpioIF* gpioComIF);
 void createTestComponents(LinuxLibgpioIF* gpioComIF);
--- a/bsp_q7s/core/obsw.cpp
+++ b/bsp_q7s/core/obsw.cpp
@ -15,7 +15,7 @@ static int OBSW_ALREADY_RUNNING = -2;
 int obsw::obsw() {
  using namespace fsfw;
  std::cout << "-- EIVE OBSW --" << std::endl;
-#if BOARD_TE0720 == 0
+#ifdef TE0720_1CFA
  std::cout << "-- Compiled for Linux (Xiphos Q7S) --" << std::endl;
 #else
  std::cout << "-- Compiled for Linux (TE0720) --" << std::endl;