eive-obsw/mission/tmtc/CCSDSHandler.h

#ifndef CCSDSHANDLER_H_
#define CCSDSHANDLER_H_

#include <unordered_map>

#include "CCSDSActions.h"
#include "OBSWConfig.h"
#include "VirtualChannel.h"
#include "fsfw/action/ActionHelper.h"
#include "fsfw/action/HasActionsIF.h"
#include "fsfw/events/EventMessage.h"
#include "fsfw/objectmanager/SystemObject.h"
#include "fsfw/parameters/ParameterHelper.h"
#include "fsfw/returnvalues/HasReturnvaluesIF.h"
#include "fsfw/tasks/ExecutableObjectIF.h"
#include "fsfw/timemanager/Countdown.h"
#include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
#include "fsfw/tmtcservices/AcceptsTelemetryIF.h"
#include "fsfw_hal/common/gpio/GpioIF.h"
#include "fsfw_hal/common/gpio/gpioDefinitions.h"
#include "linux/obc/PtmeConfig.h"

/**
 * @brief   This class handles the data exchange with the CCSDS IP cores implemented in the
 *          programmable logic of the Q7S.
 *
 * @details After reboot default CADU bitrate is always set to 100 kbps (results in downlink rate
 *          of 200 kbps due to convolutional code added by syrlinks transceiver)
 *
 * @author  J. Meier
 */
class CCSDSHandler : public SystemObject,
                     public ExecutableObjectIF,
                     public AcceptsTelemetryIF,
                     public AcceptsTelecommandsIF,
                     public HasReturnvaluesIF,
                     public ReceivesParameterMessagesIF,
                     public HasActionsIF {
 public:
  using VcId_t = uint8_t;

  /**
   * @brief Constructor
   *
   * @param objectId  Object ID of the CCSDS handler
   * @param ptmeId    Object ID of the PTME object providing access to the PTME IP Core.
   * @param tcDestination Object ID of object handling received TC space packets
   * @param txRateSetter  Object providing the functionality to switch the input bitrate of
   *                      the S-Band transceiver.
   * @param gpioIF    Required to enable TX data and TX clock RS485 transceiver chips.
   * @param enTxClock GPIO ID of RS485 tx clock enable
   * @param enTxData  GPIO ID of RS485 tx data enable
   */
  CCSDSHandler(object_id_t objectId, object_id_t ptmeId, object_id_t tcDestination,
               PtmeConfig* ptmeConfig, GpioIF* gpioIF, gpioId_t enTxClock, gpioId_t enTxData,
               uint32_t transmitterTimeout = 900000);

  ~CCSDSHandler();

  ReturnValue_t performOperation(uint8_t operationCode = 0) override;
  ReturnValue_t initialize();
  MessageQueueId_t getCommandQueue() const;

  /**
   * @brief   Function to add a virtual channel
   *
   * @param virtualChannelId  ID of the virtual channel to add
   * @param virtualChannel    Pointer to virtual channel object
   */
  void addVirtualChannel(VcId_t virtualChannelId, VirtualChannel* virtualChannel);

  MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0);
  ReturnValue_t getParameter(uint8_t domainId, uint8_t uniqueIdentifier,
                             ParameterWrapper* parameterWrapper, const ParameterWrapper* newValues,
                             uint16_t startAtIndex);

  uint16_t getIdentifier() override;
  MessageQueueId_t getRequestQueue() override;

  virtual ActionHelper* getActionHelper() override;
  virtual ReturnValue_t executeAction(Action* action);
  ReturnValue_t handleAction(SetLowRateAction* action);
  ReturnValue_t handleAction(SetHighRateAction* action);
  ReturnValue_t handleAction(EnTransmitterAction* action);
  ReturnValue_t handleAction(DisableTransmitterAction* action);
  ReturnValue_t handleAction(ArbitraryRateAction* action);
  ReturnValue_t handleAction(EnableTxClkManipulatorAction* action);
  ReturnValue_t handleAction(DisableTxClkManipulatorAction* action);
  ReturnValue_t handleAction(UpdateOnRisingEdgeAction* action);
  ReturnValue_t handleAction(UpdateOnFallingEdgeAction* action);

 private:
  static const uint8_t INTERFACE_ID = CLASS_ID::CCSDS_HANDLER;

  static const uint32_t QUEUE_SIZE = common::CCSDS_HANDLER_QUEUE_SIZE;

  // Syrlinks supports two bitrates (200 kbps and 1000 kbps)
  // Due to convolutional code added by the syrlinks the input frequency must be half the
  // target frequency
  static const uint32_t RATE_100KBPS = 100000;
  static const uint32_t RATE_500KBPS = 500000;

  //! [EXPORT] : [COMMENT] Received action message with unknown action id
  static const ReturnValue_t COMMAND_NOT_IMPLEMENTED = MAKE_RETURN_CODE(0xA0);

  static const bool UP = true;
  static const bool DOWN = false;

  using VirtualChannelMap = std::unordered_map<VcId_t, VirtualChannel*>;
  using VirtualChannelMapIter = VirtualChannelMap::iterator;

  VirtualChannelMap virtualChannelMap;

  // Object ID of PTME object
  object_id_t ptmeId;

  object_id_t tcDestination;

  MessageQueueIF* commandQueue = nullptr;
  MessageQueueIF* eventQueue = nullptr;

  ParameterHelper parameterHelper;

  ActionHelper actionHelper;

  MessageQueueId_t tcDistributorQueueId = MessageQueueIF::NO_QUEUE;

  PtmeConfig* ptmeConfig = nullptr;

  GpioIF* gpioIF = nullptr;
  gpioId_t enTxClock = gpio::NO_GPIO;
  gpioId_t enTxData = gpio::NO_GPIO;

  // Syrlinks must not be transmitting more than 15 minutes (according to datasheet)
  // Value initialized by constructor argument
  const uint32_t transmitterTimeout = 0;

  // Countdown to disable transmitter after 15 minutes
  Countdown transmitterCountdown;

  // When true transmitting is started as soon as carrier lock has been detected
  bool enableTxWhenCarrierLock = false;

  bool linkState = DOWN;

  void readCommandQueue(void);
  void handleTelemetry();
  void handleTelecommands();
  void checkEvents();
  void handleEvent(EventMessage* eventMessage);

  void handleBitLockEvent();
  void handleCarrierLockEvent();

  /**
   * @brief    Forward link state to virtual channels.
   */
  void forwardLinkstate();

  /**
   * @brief   Starts transmit timer and enables transmitter.
   */
  void enableTransmit();

  /**
   * @brief   Checks Tx timer for timeout and disables RS485 tx clock and tx data in case
   *          timer has expired.
   */
  void checkTxTimer();

  /**
   * @brief   Disables the transmitter by pulling the enable tx clock and tx data pin of the
   *          RS485 transceiver chips to high.
   */
  void disableTransmit();
};

#endif /* CCSDSHANDLER_H_ */