dummies/CMakeLists.txt

@@ -22,6 +22,8 @@ target_sources(
          PlPcduDummy.cpp
          ScexDummy.cpp
          CoreControllerDummy.cpp
+         PlocMpsocDummy.cpp
+         PlocSupervisorDummy.cpp
          helpers.cpp
          MgmRm3100Dummy.cpp
          Tmp1075Dummy.cpp)

dummies/PlocMpsocDummy.cpp

@@ -0,0 +1,42 @@
+#include "PlocMpsocDummy.h"
+
+PlocMpsocDummy::PlocMpsocDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+PlocMpsocDummy::~PlocMpsocDummy() {}
+
+void PlocMpsocDummy::doStartUp() {}
+
+void PlocMpsocDummy::doShutDown() {}
+
+ReturnValue_t PlocMpsocDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PlocMpsocDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PlocMpsocDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                      const uint8_t *commandData,
+                                                      size_t commandDataLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocDummy::scanForReply(const uint8_t *start, size_t len,
+                                           DeviceCommandId_t *foundId, size_t *foundLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocMpsocDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return returnvalue::OK;
+}
+
+void PlocMpsocDummy::fillCommandAndReplyMap() {}
+
+uint32_t PlocMpsocDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t PlocMpsocDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                      LocalDataPoolManager &poolManager) {
+  return returnvalue::OK;
+}

dummies/PlocMpsocDummy.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class PlocMpsocDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  PlocMpsocDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~PlocMpsocDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};

dummies/PlocSupervisorDummy.cpp

@@ -0,0 +1,44 @@
+#include "PlocSupervisorDummy.h"
+
+PlocSupervisorDummy::PlocSupervisorDummy(object_id_t objectId, object_id_t comif,
+                                         CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie) {}
+
+PlocSupervisorDummy::~PlocSupervisorDummy() {}
+
+void PlocSupervisorDummy::doStartUp() {}
+
+void PlocSupervisorDummy::doShutDown() {}
+
+ReturnValue_t PlocSupervisorDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PlocSupervisorDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PlocSupervisorDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                           const uint8_t *commandData,
+                                                           size_t commandDataLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocSupervisorDummy::scanForReply(const uint8_t *start, size_t len,
+                                                DeviceCommandId_t *foundId, size_t *foundLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t PlocSupervisorDummy::interpretDeviceReply(DeviceCommandId_t id,
+                                                        const uint8_t *packet) {
+  return returnvalue::OK;
+}
+
+void PlocSupervisorDummy::fillCommandAndReplyMap() {}
+
+uint32_t PlocSupervisorDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t PlocSupervisorDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                           LocalDataPoolManager &poolManager) {
+  return returnvalue::OK;
+}

dummies/PlocSupervisorDummy.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+
+class PlocSupervisorDummy : public DeviceHandlerBase {
+ public:
+  static const DeviceCommandId_t SIMPLE_COMMAND = 1;
+  static const DeviceCommandId_t PERIODIC_REPLY = 2;
+
+  static const uint8_t SIMPLE_COMMAND_DATA = 1;
+  static const uint8_t PERIODIC_REPLY_DATA = 2;
+
+  PlocSupervisorDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~PlocSupervisorDummy();
+
+ protected:
+  void doStartUp() override;
+  void doShutDown() override;
+  ReturnValue_t buildNormalDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildTransitionDeviceCommand(DeviceCommandId_t *id) override;
+  ReturnValue_t buildCommandFromCommand(DeviceCommandId_t deviceCommand, const uint8_t *commandData,
+                                        size_t commandDataLen) override;
+  ReturnValue_t scanForReply(const uint8_t *start, size_t len, DeviceCommandId_t *foundId,
+                             size_t *foundLen) override;
+  ReturnValue_t interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) override;
+  void fillCommandAndReplyMap() override;
+  uint32_t getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) override;
+  ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                        LocalDataPoolManager &poolManager) override;
+};

dummies/ScexDummy.h

@@ -1,5 +1,4 @@
-#ifndef DUMMIES_SCEXDUMMY_H_
+#pragma once
-#define DUMMIES_SCEXDUMMY_H_
 
 #include <fsfw/devicehandlers/DeviceHandlerBase.h>
 
@@ -29,6 +28,3 @@ class ScexDummy : public DeviceHandlerBase {
   ReturnValue_t initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
                                         LocalDataPoolManager &poolManager) override;
 };
-
-
-#endif /* DUMMIES_SCEXDUMMY_H_ */

dummies/helpers.cpp

@@ -15,12 +15,15 @@
 #include <dummies/P60DockDummy.h>
 #include <dummies/PduDummy.h>
 #include <dummies/PlPcduDummy.h>
+#include <dummies/PlocMpsocDummy.h>
+#include <dummies/PlocSupervisorDummy.h>
 #include <dummies/RwDummy.h>
 #include <dummies/SaDeploymentDummy.h>
 #include <dummies/ScexDummy.h>
 #include <dummies/StarTrackerDummy.h>
 #include <dummies/SusDummy.h>
 #include <dummies/SyrlinksDummy.h>
+#include <fsfw_hal/common/gpio/GpioIF.h>
 #include <mission/system/objects/CamSwitcher.h>
 #include <mission/system/objects/TcsBoardAssembly.h>
 
@@ -30,9 +33,9 @@
 #include "mission/core/GenericFactory.h"
 #include "mission/devices/devicedefinitions/GomspaceDefinitions.h"
 #include "mission/system/tree/acsModeTree.h"
+#include "mission/system/tree/comModeTree.h"
 #include "mission/system/tree/payloadModeTree.h"
-
+#include "mission/system/tree/tcsModeTree.h"
-using namespace dummy;
 
 void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpioIF) {
   new ComIFDummy(objects::DUMMY_COM_IF);
@@ -56,7 +59,9 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
       new StarTrackerDummy(objects::STAR_TRACKER, objects::DUMMY_COM_IF, comCookieDummy);
   strDummy->connectModeTreeParent(satsystem::acs::ACS_SUBSYSTEM);
   if (cfg.addSyrlinksDummies) {
+    auto* syrlinksDummy =
         new SyrlinksDummy(objects::SYRLINKS_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    syrlinksDummy->connectModeTreeParent(satsystem::com::SUBSYSTEM);
   }
   auto* imtqDummy = new ImtqDummy(objects::IMTQ_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
   imtqDummy->enableThermalModule(ThermalStateCfg());
@@ -120,83 +125,96 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
   }
 
   if (cfg.addTempSensorDummies) {
-    std::map<object_id_t, Max31865Dummy*> tempSensorDummies;
+    std::map<object_id_t, Max31865Dummy*> rtdSensorDummies;
-    tempSensorDummies.emplace(objects::RTD_0_IC3_PLOC_HEATSPREADER,
+    rtdSensorDummies.emplace(objects::RTD_0_IC3_PLOC_HEATSPREADER,
                              new Max31865Dummy(objects::RTD_0_IC3_PLOC_HEATSPREADER,
                                                objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(objects::RTD_1_IC4_PLOC_MISSIONBOARD,
+    rtdSensorDummies.emplace(objects::RTD_1_IC4_PLOC_MISSIONBOARD,
                              new Max31865Dummy(objects::RTD_1_IC4_PLOC_MISSIONBOARD,
                                                objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
         objects::RTD_2_IC5_4K_CAMERA,
         new Max31865Dummy(objects::RTD_2_IC5_4K_CAMERA, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(objects::RTD_3_IC6_DAC_HEATSPREADER,
+    rtdSensorDummies.emplace(objects::RTD_3_IC6_DAC_HEATSPREADER,
                              new Max31865Dummy(objects::RTD_3_IC6_DAC_HEATSPREADER,
                                                objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
         objects::RTD_4_IC7_STARTRACKER,
         new Max31865Dummy(objects::RTD_4_IC7_STARTRACKER, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
         objects::RTD_5_IC8_RW1_MX_MY,
         new Max31865Dummy(objects::RTD_5_IC8_RW1_MX_MY, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
         objects::RTD_6_IC9_DRO,
         new Max31865Dummy(objects::RTD_6_IC9_DRO, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
         objects::RTD_7_IC10_SCEX,
         new Max31865Dummy(objects::RTD_7_IC10_SCEX, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
         objects::RTD_8_IC11_X8,
         new Max31865Dummy(objects::RTD_8_IC11_X8, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
         objects::RTD_9_IC12_HPA,
         new Max31865Dummy(objects::RTD_9_IC12_HPA, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
         objects::RTD_10_IC13_PL_TX,
         new Max31865Dummy(objects::RTD_10_IC13_PL_TX, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
         objects::RTD_11_IC14_MPA,
         new Max31865Dummy(objects::RTD_11_IC14_MPA, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
         objects::RTD_12_IC15_ACU,
         new Max31865Dummy(objects::RTD_12_IC15_ACU, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(objects::RTD_13_IC16_PLPCDU_HEATSPREADER,
+    rtdSensorDummies.emplace(objects::RTD_13_IC16_PLPCDU_HEATSPREADER,
                              new Max31865Dummy(objects::RTD_13_IC16_PLPCDU_HEATSPREADER,
                                                objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
         objects::RTD_14_IC17_TCS_BOARD,
         new Max31865Dummy(objects::RTD_14_IC17_TCS_BOARD, objects::DUMMY_COM_IF, comCookieDummy));
-    tempSensorDummies.emplace(
+    rtdSensorDummies.emplace(
         objects::RTD_15_IC18_IMTQ,
         new Max31865Dummy(objects::RTD_15_IC18_IMTQ, objects::DUMMY_COM_IF, comCookieDummy));
 
-    std::map<object_id_t, Tmp1075Dummy*> tempTmpSensorDummies;
+    std::map<object_id_t, Tmp1075Dummy*> tmpSensorDummies;
-    tempTmpSensorDummies.emplace(
+    tmpSensorDummies.emplace(
         objects::TMP1075_HANDLER_TCS_0,
         new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_0, objects::DUMMY_COM_IF, comCookieDummy));
-    tempTmpSensorDummies.emplace(
+    tmpSensorDummies.emplace(
         objects::TMP1075_HANDLER_TCS_1,
         new Tmp1075Dummy(objects::TMP1075_HANDLER_TCS_1, objects::DUMMY_COM_IF, comCookieDummy));
-    tempTmpSensorDummies.emplace(
+    tmpSensorDummies.emplace(
         objects::TMP1075_HANDLER_PLPCDU_0,
         new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_0, objects::DUMMY_COM_IF, comCookieDummy));
-    tempTmpSensorDummies.emplace(
+    tmpSensorDummies.emplace(
         objects::TMP1075_HANDLER_PLPCDU_1,
         new Tmp1075Dummy(objects::TMP1075_HANDLER_PLPCDU_1, objects::DUMMY_COM_IF, comCookieDummy));
-    tempTmpSensorDummies.emplace(
+    tmpSensorDummies.emplace(
         objects::TMP1075_HANDLER_IF_BOARD,
         new Tmp1075Dummy(objects::TMP1075_HANDLER_IF_BOARD, objects::DUMMY_COM_IF, comCookieDummy));
 
-    new TemperatureSensorInserter(objects::THERMAL_TEMP_INSERTER, tempSensorDummies,
+    new TemperatureSensorInserter(objects::THERMAL_TEMP_INSERTER, rtdSensorDummies,
-                                  tempTmpSensorDummies);
+                                  tmpSensorDummies);
     TcsBoardAssembly* tcsBoardAssy = ObjectFactory::createTcsBoardAssy(pwrSwitcher);
-    for (auto& rtd : tempSensorDummies) {
+    for (auto& rtd : rtdSensorDummies) {
       rtd.second->connectModeTreeParent(*tcsBoardAssy);
     }
+    for (auto& tmp : tmpSensorDummies) {
+      tmp.second->connectModeTreeParent(satsystem::tcs::SUBSYSTEM);
+    }
   }
   auto* camSwitcher = new CamSwitcher(objects::CAM_SWITCHER, pwrSwitcher, power::NO_SWITCH);
   camSwitcher->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
   auto* scexDummy = new ScexDummy(objects::SCEX, objects::DUMMY_COM_IF, comCookieDummy);
   scexDummy->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+  auto* plPcduDummy =
       new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+  plPcduDummy->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+  if (cfg.addPlocDummies) {
+    auto* plocMpsocDummy =
+        new PlocMpsocDummy(objects::PLOC_MPSOC_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
+    plocMpsocDummy->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+    auto* plocSupervisorDummy = new PlocSupervisorDummy(objects::PLOC_SUPERVISOR_HANDLER,
+                                                        objects::DUMMY_COM_IF, comCookieDummy);
+    plocSupervisorDummy->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+  }
 }

dummies/helpers.h

@@ -14,6 +14,7 @@ struct DummyCfg {
   bool addSusDummies = true;
   bool addTempSensorDummies = true;
   bool addRtdComIFDummy = true;
+  bool addPlocDummies = true;
 };
 
 void createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitch, GpioIF* gpioIF);