payload mode announce

dummies/CMakeLists.txt

@@ -7,6 +7,7 @@ target_sources(
          ComCookieDummy.cpp
          RwDummy.cpp
          Max31865Dummy.cpp
+         PcduHandlerDummy.cpp
          StarTrackerDummy.cpp
          SyrlinksDummy.cpp
          ImtqDummy.cpp

dummies/PcduHandlerDummy.cpp

@@ -0,0 +1,62 @@
+#include "PcduHandlerDummy.h"
+
+#include <mission/devices/devicedefinitions/GomspaceDefinitions.h>
+
+PcduHandlerDummy::PcduHandlerDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie)
+    : DeviceHandlerBase(objectId, comif, comCookie), dummySwitcher(objectId, 18, 18, false) {}
+
+PcduHandlerDummy::~PcduHandlerDummy() {}
+
+void PcduHandlerDummy::doStartUp() { setMode(MODE_NORMAL); }
+
+void PcduHandlerDummy::doShutDown() { setMode(MODE_OFF); }
+
+ReturnValue_t PcduHandlerDummy::buildNormalDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PcduHandlerDummy::buildTransitionDeviceCommand(DeviceCommandId_t *id) {
+  return NOTHING_TO_SEND;
+}
+
+ReturnValue_t PcduHandlerDummy::buildCommandFromCommand(DeviceCommandId_t deviceCommand,
+                                                        const uint8_t *commandData,
+                                                        size_t commandDataLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t PcduHandlerDummy::scanForReply(const uint8_t *start, size_t len,
+                                             DeviceCommandId_t *foundId, size_t *foundLen) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t PcduHandlerDummy::interpretDeviceReply(DeviceCommandId_t id, const uint8_t *packet) {
+  return returnvalue::OK;
+}
+
+void PcduHandlerDummy::fillCommandAndReplyMap() {}
+
+uint32_t PcduHandlerDummy::getTransitionDelayMs(Mode_t modeFrom, Mode_t modeTo) { return 500; }
+
+ReturnValue_t PcduHandlerDummy::initializeLocalDataPool(localpool::DataPool &localDataPoolMap,
+                                                        LocalDataPoolManager &poolManager) {
+  return returnvalue::OK;
+}
+
+ReturnValue_t PcduHandlerDummy::sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) {
+  return dummySwitcher.sendSwitchCommand(switchNr, onOff);
+}
+
+ReturnValue_t PcduHandlerDummy::sendFuseOnCommand(uint8_t fuseNr) {
+  return dummySwitcher.sendFuseOnCommand(fuseNr);
+}
+
+ReturnValue_t PcduHandlerDummy::getSwitchState(power::Switch_t switchNr) const {
+  return dummySwitcher.getSwitchState(switchNr);
+}
+
+ReturnValue_t PcduHandlerDummy::getFuseState(uint8_t fuseNr) const {
+  return dummySwitcher.getFuseState(fuseNr);
+}
+
+uint32_t PcduHandlerDummy::getSwitchDelayMs(void) const { return dummySwitcher.getSwitchDelayMs(); }

dummies/PcduHandlerDummy.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <fsfw/devicehandlers/DeviceHandlerBase.h>
+#include <fsfw/power/DummyPowerSwitcher.h>
+
+class PcduHandlerDummy : public DeviceHandlerBase, public PowerSwitchIF {
+ 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;
+
+  PcduHandlerDummy(object_id_t objectId, object_id_t comif, CookieIF *comCookie);
+  virtual ~PcduHandlerDummy();
+
+ protected:
+  DummyPowerSwitcher dummySwitcher;
+
+  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;
+
+  ReturnValue_t sendSwitchCommand(power::Switch_t switchNr, ReturnValue_t onOff) override;
+  ReturnValue_t sendFuseOnCommand(uint8_t fuseNr) override;
+  ReturnValue_t getSwitchState(power::Switch_t switchNr) const override;
+  ReturnValue_t getFuseState(uint8_t fuseNr) const override;
+  uint32_t getSwitchDelayMs(void) const override;
+};

dummies/helpers.cpp

@@ -210,18 +210,18 @@ void dummy::createDummies(DummyCfg cfg, PowerSwitchIF& pwrSwitcher, GpioIF* gpio
     }
   }
   auto* camSwitcher = new CamSwitcher(objects::CAM_SWITCHER, pwrSwitcher, power::NO_SWITCH);
-  camSwitcher->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+  camSwitcher->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
   auto* scexDummy = new ScexDummy(objects::SCEX, objects::DUMMY_COM_IF, comCookieDummy);
-  scexDummy->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+  scexDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
   auto* plPcduDummy =
       new PlPcduDummy(objects::PLPCDU_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-  plPcduDummy->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+  plPcduDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
   if (cfg.addPlocDummies) {
     auto* plocMpsocDummy =
         new PlocMpsocDummy(objects::PLOC_MPSOC_HANDLER, objects::DUMMY_COM_IF, comCookieDummy);
-    plocMpsocDummy->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+    plocMpsocDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
     auto* plocSupervisorDummy = new PlocSupervisorDummy(objects::PLOC_SUPERVISOR_HANDLER,
                                                         objects::DUMMY_COM_IF, comCookieDummy);
-    plocSupervisorDummy->connectModeTreeParent(satsystem::pl::SUBSYSTEM);
+    plocSupervisorDummy->connectModeTreeParent(satsystem::payload::SUBSYSTEM);
   }
 }