Merge remote-tracking branch 'origin/develop' into bugfix_shadowed_variables_dual_assys

mission/system/objects/ComSubsystem.cpp

@@ -1,13 +1,36 @@
 #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/comDefs.h>
+#include <mission/config/comCfg.h>
 
-#include "mission/config/comCfg.h"
+#include <utility>
 
 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();
+  // Execute default rate sequence after transition has been completed
+  if (rememberBitLock and not isInTransition) {
+    startRxAndTxLowRateSeq();
+    rememberBitLock = false;
+  }
+  if (countdownActive) {
+    checkTransmitterCountdown();
+  }
+  Subsystem::performChildOperation();
 }
 
 MessageQueueId_t ComSubsystem::getCommandQueue() const { return Subsystem::getCommandQueue(); }
@@ -27,6 +50,17 @@ ReturnValue_t ComSubsystem::getParameter(uint8_t domainId, uint8_t uniqueIdentif
     parameterWrapper->set(datarateCfg);
     com::setCurrentDatarate(static_cast<com::Datarate>(newVal));
     return returnvalue::OK;
+  } else if ((domainId == 0) and
+             (uniqueIdentifier == static_cast<uint8_t>(com::ParameterId::TRANSMITTER_TIMEOUT))) {
+    uint32_t newVal = 0;
+    ReturnValue_t result = newValues->getElement(&newVal);
+    if (result != returnvalue::OK) {
+      return result;
+    }
+    parameterWrapper->set(transmitterTimeout);
+    transmitterTimeout = newVal;
+    transmitterCountdown.setTimeout(transmitterTimeout);
+    return returnvalue::OK;
   }
   return returnvalue::OK;
 }
@@ -44,5 +78,121 @@ 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 submode the transmitter timeout is enabled or
+  // disabled here
+  if (mode == com::Submode::RX_ONLY) {
+    transmitterCountdown.timeOut();
+    countdownActive = false;
+  } else if (isTxMode(mode)) {
+    // Only start transmitter countdown if transmitter is not already on
+    if (not isTxMode(this->mode)) {
+      transmitterCountdown.resetTimer();
+      countdownActive = true;
+    }
+  }
+  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() {
+  if (isTxMode(mode)) {
+    // Tx already on
+    return;
+  }
+  if (isInTransition) {
+    rememberBitLock = true;
+    return;
+  }
+  startRxAndTxLowRateSeq();
+}
+
+void ComSubsystem::handleCarrierLockEvent() {
+  if (!enableTxWhenCarrierLock) {
+    return;
+  }
+  startRxAndTxLowRateSeq();
+}
+
+void ComSubsystem::startRxAndTxLowRateSeq() {
+  // Turns transmitter on
+  startTransition(com::Submode::RX_AND_TX_LOW_DATARATE, SUBMODE_NONE);
+}
+
+void ComSubsystem::checkTransmitterCountdown() {
+  if (transmitterCountdown.hasTimedOut()) {
+    startTransition(com::Submode::RX_ONLY, SUBMODE_NONE);
+    countdownActive = false;
+  }
+}
+
+bool ComSubsystem::isTxMode(Mode_t mode) {
+  if ((mode == com::Submode::RX_AND_TX_DEFAULT_DATARATE) ||
+      (mode == com::Submode::RX_AND_TX_LOW_DATARATE) ||
+      (mode == com::Submode::RX_AND_TX_HIGH_DATARATE)) {
+    return true;
+  }
+  return false;
+}

mission/system/objects/ComSubsystem.h

@@ -1,6 +1,7 @@
 #ifndef MISSION_SYSTEM_COMSUBSYSTEM_H_
 #define MISSION_SYSTEM_COMSUBSYSTEM_H_
 
+#include <fsfw/events/EventMessage.h>
 #include <fsfw/parameters/HasParametersIF.h>
 #include <fsfw/parameters/ParameterHelper.h>
 #include <fsfw/subsystem/Subsystem.h>
@@ -9,21 +10,71 @@
 
 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:
+  static const Mode_t INITIAL_MODE = 0;
+
   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 low rate mode
+   */
+  void startRxAndTxLowRateSeq();
+
+  /**
+   * @brief	Returns true if mode is a mode where the transmitter is on
+   */
+  bool isTxMode(Mode_t mode);
+
   uint8_t datarateCfg = static_cast<uint8_t>(com::Datarate::LOW_RATE_MODULATION_BPSK);
+  // 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;
   ParameterHelper paramHelper;
+
+  MessageQueueIF *eventQueue = nullptr;
+
+  bool enableTxWhenCarrierLock = false;
+
+  // Countdown will be started as soon as the transmitter was enabled
+  Countdown transmitterCountdown;
+
+  // Transmitter countdown only active when sysrlinks transmitter is on (modes:
+  // rx and tx low rate, rx and tx high rate, rx and tx default rate)
+  bool countdownActive = false;
+
+  // True when bit lock occurred while COM subsystem is in a transition. This
+  // variable is used to remember the bit lock and execute the default rate
+  // sequence after the active transition has been completed
+  bool rememberBitLock = false;
 };
 
 #endif /* MISSION_SYSTEM_COMSUBSYSTEM_H_ */