moved transmitter timer and event handling of carrier and bitlock to ComSubsystem

mission/system/objects/ComSubsystem.cpp

@@ -1,13 +1,32 @@
+#include <utility>
+
 #include "ComSubsystem.h"
 
+#include <fsfw/events/EventManagerIF.h>
 #include <fsfw/ipc/MutexGuard.h>
+#include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/serviceinterface/ServiceInterface.h>
+#include <linux/ipcore/PdecHandler.h>
+#include <mission/config/comCfg.h>
 
-#include "mission/config/comCfg.h"
+extern std::pair<uint8_t, FixedArrayList<ModeListEntry, 3>> COM_SEQUENCE_RX_ONLY;
+extern std::pair<uint8_t, FixedArrayList<ModeListEntry, 3>> COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE;
+extern std::pair<uint8_t, FixedArrayList<ModeListEntry, 3>> COM_SEQUENCE_RX_AND_TX_LOW_RATE;
+extern std::pair<uint8_t, FixedArrayList<ModeListEntry, 3>> COM_SEQUENCE_RX_AND_TX_HIGH_RATE;
 
 ComSubsystem::ComSubsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences,
-                           uint32_t maxNumberOfTables)
+                           uint32_t maxNumberOfTables, uint32_t transmitterTimeout)
     : Subsystem(setObjectId, maxNumberOfSequences, maxNumberOfTables), paramHelper(this) {
   com::setCurrentDatarate(com::Datarate::LOW_RATE_MODULATION_BPSK);
+  auto mqArgs = MqArgs(setObjectId, static_cast<void *>(this));
+  eventQueue =
+      QueueFactory::instance()->createMessageQueue(10, EventMessage::EVENT_MESSAGE_SIZE, &mqArgs);
+  transmitterCountdown.setTimeout(transmitterTimeout);
+}
+
+void ComSubsystem::performChildOperation() {
+  readEventQueue();
+  checkTransmitterCountdown();
 }
 
 MessageQueueId_t ComSubsystem::getCommandQueue() const { return Subsystem::getCommandQueue(); }
@@ -44,5 +63,97 @@ ReturnValue_t ComSubsystem::initialize() {
   if (result != returnvalue::OK) {
     return result;
   }
+  EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(objects::EVENT_MANAGER);
+    if (manager == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::error << "ComSubsystem::initialize: Invalid event manager" << std::endl;
+#endif
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	result = manager->registerListener(eventQueue->getId());
+	if (result != returnvalue::OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::warning << "ComSubsystem::initialize: Failed to register Com Subsystem as event "
+										"listener" << std::endl;
+#endif
+		return ObjectManagerIF::CHILD_INIT_FAILED;
+	}
+	result = manager->subscribeToEventRange(eventQueue->getId(),
+																					event::getEventId(PdecHandler::CARRIER_LOCK),
+																					event::getEventId(PdecHandler::BIT_LOCK_PDEC));
+	if (result != returnvalue::OK) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+		sif::error << "ComSubsystem::initialize: Failed to subscribe to events from PDEC "
+									"handler"
+							 << std::endl;
+#endif
+		return result;
+	}
   return Subsystem::initialize();
 }
+
+void ComSubsystem::startTransition(Mode_t mode, Submode_t submode) {
+  // Depending on the mode the transmitter timeout is enabled or
+  // disabled here
+  if (mode == COM_SEQUENCE_RX_ONLY.first) {
+    transmitterCountdown.timeOut();
+  } else if ((mode == COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE.first) ||
+             (mode == COM_SEQUENCE_RX_AND_TX_LOW_RATE.first) ||
+             (mode == COM_SEQUENCE_RX_AND_TX_HIGH_RATE.first)) {
+    transmitterCountdown.resetTimer();
+  }
+  Subsystem::startTransition(mode, submode);
+}
+
+void ComSubsystem::readEventQueue() {
+  EventMessage event;
+  for (ReturnValue_t result = eventQueue->receiveMessage(&event); result == returnvalue::OK;
+       result = eventQueue->receiveMessage(&event)) {
+    switch (event.getMessageId()) {
+      case EventMessage::EVENT_MESSAGE:
+        handleEventMessage(&event);
+        break;
+      default:
+        sif::debug << "CcsdsHandler::checkEvents: Did not subscribe to this event message"
+                   << std::endl;
+        break;
+    }
+  }
+}
+
+void ComSubsystem::handleEventMessage(EventMessage *eventMessage) {
+  Event event = eventMessage->getEvent();
+  switch (event) {
+    case PdecHandler::BIT_LOCK_PDEC: {
+      handleBitLockEvent();
+      break;
+    }
+    case PdecHandler::CARRIER_LOCK: {
+      handleCarrierLockEvent();
+      break;
+    }
+    default:
+      sif::debug << "ComSubsystem::handleEvent: Did not subscribe to this event" << std::endl;
+      break;
+  }
+}
+
+void ComSubsystem::handleBitLockEvent() { startRxAndTxDefaultSeq(); }
+
+void ComSubsystem::handleCarrierLockEvent() {
+  if (!enableTxWhenCarrierLock) {
+    return;
+  }
+  startRxAndTxDefaultSeq();
+}
+
+void ComSubsystem::startRxAndTxDefaultSeq() {
+  // Turns transmitter on
+  startTransition(COM_SEQUENCE_RX_AND_TX_DEFAULT_RATE.first, SUBMODE_NONE);
+}
+
+void ComSubsystem::checkTransmitterCountdown() {
+  if (transmitterCountdown.hasTimedOut()) {
+    startTransition(COM_SEQUENCE_RX_ONLY.first, SUBMODE_NONE);
+  }
+}

mission/system/objects/ComSubsystem.h

@@ -4,26 +4,61 @@
 #include <fsfw/parameters/HasParametersIF.h>
 #include <fsfw/parameters/ParameterHelper.h>
 #include <fsfw/subsystem/Subsystem.h>
+#include <fsfw/events/EventMessage.h>
 
 #include "mission/comDefs.h"
 
 class ComSubsystem : public Subsystem, public ReceivesParameterMessagesIF {
  public:
-  ComSubsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables);
+	/**
+	 * @brief Constructor
+	 *
+	 * @param setObjectId
+	 * @param maxNumberOfSequences
+	 * @param maxNumberOfTables
+	 * @param transmitterTimeout	Maximum time the transmitter of the syrlinks
+	 * 														will be enabled
+	 */
+  ComSubsystem(object_id_t setObjectId, uint32_t maxNumberOfSequences, uint32_t maxNumberOfTables,
+               uint32_t transmitterTimeout);
   virtual ~ComSubsystem() = default;
 
   MessageQueueId_t getCommandQueue() const override;
   ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
                              ParameterWrapper *parameterWrapper, const ParameterWrapper *newValues,
                              uint16_t startAtIndex) override;
+  virtual void performChildOperation() override;
 
  private:
   ReturnValue_t handleCommandMessage(CommandMessage *message) override;
 
   ReturnValue_t initialize() override;
 
+  void startTransition(Mode_t mode, Submode_t submode) override;
+
+  void readEventQueue();
+  void handleEventMessage(EventMessage* eventMessage);
+  void handleBitLockEvent();
+  void handleCarrierLockEvent();
+  void checkTransmitterCountdown();
+  /**
+   * @brief	Enables transmitter in default (low) rate mode
+   */
+  void startRxAndTxDefaultSeq();
+
   uint8_t datarateCfg = static_cast<uint8_t>(com::Datarate::LOW_RATE_MODULATION_BPSK);
   ParameterHelper paramHelper;
+
+  MessageQueueIF* eventQueue = nullptr;
+
+  bool enableTxWhenCarrierLock = false;
+
+  // Maximum time after which the transmitter will be turned of. This is a
+  // protection mechanism due prevent the syrlinks from overheating
+  uint32_t transmitterTimeout = 0;
+
+  // Countdown will be started as soon as the transmitter was enabled
+  Countdown transmitterCountdown;
 };
 
 #endif /* MISSION_SYSTEM_COMSUBSYSTEM_H_ */