bsp_te0720_1cfa/ObjectFactory.cpp

@@ -43,7 +43,11 @@ void Factory::setStaticFrameworkObjectIds() {
   CommandingServiceBase::defaultPacketSource = objects::PUS_PACKET_DISTRIBUTOR;
   CommandingServiceBase::defaultPacketDestination = objects::TM_FUNNEL;
 
+#if OBSW_TM_TO_PTME == 1
+  TmFunnel::downlinkDestination = objects::CCSDS_HANDLER;
+#else
   TmFunnel::downlinkDestination = objects::TMTC_BRIDGE;
+#endif
   TmFunnel::storageDestination = objects::NO_OBJECT;
 
   VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIFICATION;

fsfw

@@ -1 +1 @@
-Subproject commit cda81fc8415c3873c035aa7ebbfa3fe93d519f08
+Subproject commit 36669fd4d914a2397a0c64e3292dde7145b1f077

mission/tmtc/CCSDSHandler.cpp

@@ -130,7 +130,8 @@ ReturnValue_t CCSDSHandler::initialize() {
   }
 
 #if OBSW_SYRLINKS_SIMULATED == 1
-  ptmeConfig->invertTxClock(true);
+  // Update data on rising edge
+  ptmeConfig->invertTxClock(false);
 #endif /* OBSW_SYRLINKS_SIMULATED == 1*/
 
   return result;

mission/tmtc/TmFunnel.cpp

@@ -0,0 +1,114 @@
+#include <fsfw/ipc/QueueFactory.h>
+#include <fsfw/objectmanager/ObjectManager.h>
+#include <fsfw/serviceinterface/ServiceInterfaceStream.h>
+#include <fsfw/tmtcpacket/pus/tm.h>
+#include <mission/tmtc/TmFunnel.h>
+
+#include "OBSWConfig.h"
+
+object_id_t TmFunnel::downlinkDestination = objects::NO_OBJECT;
+object_id_t TmFunnel::storageDestination = objects::NO_OBJECT;
+
+TmFunnel::TmFunnel(object_id_t objectId, uint32_t messageDepth, uint8_t reportReceptionVc)
+    : SystemObject(objectId), messageDepth(messageDepth), reportReceptionVc(reportReceptionVc) {
+  auto mqArgs = MqArgs(objectId, static_cast<void*>(this));
+  tmQueue = QueueFactory::instance()->createMessageQueue(
+      messageDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+  storageQueue = QueueFactory::instance()->createMessageQueue(
+      messageDepth, MessageQueueMessage::MAX_MESSAGE_SIZE, &mqArgs);
+}
+
+TmFunnel::~TmFunnel() {}
+
+MessageQueueId_t TmFunnel::getReportReceptionQueue(uint8_t virtualChannel) {
+  return tmQueue->getId();
+}
+
+ReturnValue_t TmFunnel::performOperation(uint8_t operationCode) {
+  TmTcMessage currentMessage;
+  ReturnValue_t status = tmQueue->receiveMessage(&currentMessage);
+  while (status == HasReturnvaluesIF::RETURN_OK) {
+    status = handlePacket(&currentMessage);
+    if (status != HasReturnvaluesIF::RETURN_OK) {
+      break;
+    }
+    status = tmQueue->receiveMessage(&currentMessage);
+  }
+
+  if (status == MessageQueueIF::EMPTY) {
+    return HasReturnvaluesIF::RETURN_OK;
+  } else {
+    return status;
+  }
+}
+
+ReturnValue_t TmFunnel::handlePacket(TmTcMessage* message) {
+  uint8_t* packetData = nullptr;
+  size_t size = 0;
+  ReturnValue_t result = tmStore->modifyData(message->getStorageId(), &packetData, &size);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  TmPacketPusC packet(packetData);
+  packet.setPacketSequenceCount(this->sourceSequenceCount);
+  sourceSequenceCount++;
+  sourceSequenceCount = sourceSequenceCount % SpacePacketBase::LIMIT_SEQUENCE_COUNT;
+  packet.setErrorControl();
+
+  result = tmQueue->sendToDefault(message);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    tmStore->deleteData(message->getStorageId());
+    sif::error << "TmFunnel::handlePacket: Error sending to downlink "
+                  "handler"
+               << std::endl;
+    return result;
+  }
+
+  if (storageDestination != objects::NO_OBJECT) {
+    result = storageQueue->sendToDefault(message);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+      tmStore->deleteData(message->getStorageId());
+      sif::error << "TmFunnel::handlePacket: Error sending to storage "
+                    "handler"
+                 << std::endl;
+      return result;
+    }
+  }
+  return result;
+}
+
+ReturnValue_t TmFunnel::initialize() {
+  tmStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TM_STORE);
+  if (tmStore == nullptr) {
+    sif::error << "TmFunnel::initialize: TM store not set." << std::endl;
+    sif::error << "Make sure the tm store is set up properly"
+                  " and implements StorageManagerIF"
+               << std::endl;
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+
+  AcceptsTelemetryIF* tmTarget =
+      ObjectManager::instance()->get<AcceptsTelemetryIF>(downlinkDestination);
+  if (tmTarget == nullptr) {
+    sif::error << "TmFunnel::initialize: Downlink Destination not set." << std::endl;
+    sif::error << "Make sure the downlink destination object is set up "
+                  "properly and implements AcceptsTelemetryIF"
+               << std::endl;
+    return ObjectManagerIF::CHILD_INIT_FAILED;
+  }
+
+  tmQueue->setDefaultDestination(tmTarget->getReportReceptionQueue(reportReceptionVc));
+
+  // Storage destination is optional.
+  if (storageDestination == objects::NO_OBJECT) {
+    return SystemObject::initialize();
+  }
+
+  AcceptsTelemetryIF* storageTarget =
+      ObjectManager::instance()->get<AcceptsTelemetryIF>(storageDestination);
+  if (storageTarget != nullptr) {
+    storageQueue->setDefaultDestination(storageTarget->getReportReceptionQueue());
+  }
+
+  return SystemObject::initialize();
+}

mission/tmtc/TmFunnel.h

@@ -0,0 +1,49 @@
+#ifndef MISSION_UTILITY_TMFUNNEL_H_
+#define MISSION_UTILITY_TMFUNNEL_H_
+
+#include <fsfw/ipc/MessageQueueIF.h>
+#include <fsfw/objectmanager/SystemObject.h>
+#include <fsfw/tasks/ExecutableObjectIF.h>
+#include <fsfw/tmtcservices/AcceptsTelemetryIF.h>
+#include <fsfw/tmtcservices/TmTcMessage.h>
+
+namespace Factory {
+void setStaticFrameworkObjectIds();
+}
+
+/**
+ * @brief       TM Recipient.
+ * @details
+ * Main telemetry receiver. All generated telemetry is funneled into
+ * this object.
+ * @ingroup     utility
+ * @author      J. Meier
+ */
+class TmFunnel : public AcceptsTelemetryIF, public ExecutableObjectIF, public SystemObject {
+  friend void(Factory::setStaticFrameworkObjectIds)();
+
+ public:
+  TmFunnel(object_id_t objectId, uint32_t messageDepth = 20, uint8_t reportReceptionVc = 0);
+  virtual ~TmFunnel();
+
+  virtual MessageQueueId_t getReportReceptionQueue(uint8_t virtualChannel = 0) override;
+  virtual ReturnValue_t performOperation(uint8_t operationCode = 0) override;
+  virtual ReturnValue_t initialize() override;
+
+ protected:
+  static object_id_t downlinkDestination;
+  static object_id_t storageDestination;
+
+ private:
+  uint32_t messageDepth = 0;
+  uint8_t reportReceptionVc = 0;
+  uint16_t sourceSequenceCount = 0;
+  MessageQueueIF* tmQueue = nullptr;
+  MessageQueueIF* storageQueue = nullptr;
+
+  StorageManagerIF* tmStore = nullptr;
+
+  ReturnValue_t handlePacket(TmTcMessage* message);
+};
+
+#endif /* MISSION_UTILITY_TMFUNNEL_H_ */