default PUS receiver set automatically now

src/fsfw/tmtcservices/CommandingServiceBase.cpp

@@ -422,7 +422,7 @@ void CommandingServiceBase::setCustomTmStore(StorageManagerIF& store) {
   tmStoreHelper.setTmStore(store);
 }
 ReturnValue_t CommandingServiceBase::setUpTcReader(store_address_t storeId) {
-  return tc::prepareTcReader(tcStore, storeId, tcReader);
+  return tc::prepareTcReader(*tcStore, storeId, tcReader);
 }
 
 void CommandingServiceBase::prepareVerificationFailureWithFullInfo(uint8_t reportId,

src/fsfw/tmtcservices/PusServiceBase.cpp

@@ -10,6 +10,7 @@
 #include "fsfw/tmtcservices/tcHelpers.h"
 
 object_id_t PusServiceBase::packetDestination = 0;
+object_id_t PusServiceBase::pusDistributor = 0;
 
 PusServiceBase::PusServiceBase(PsbParams params)
     : SystemObject(params.objectId), psbParams(params) {}
@@ -54,9 +55,11 @@ void PusServiceBase::handleRequestQueue() {
 #endif
       break;
     }
-    result = tc::prepareTcReader(tcStore, message.getStorageId(), currentPacket);
+    result = tc::prepareTcReader(*psbParams.tcPool, message.getStorageId(), currentPacket);
     if (result != HasReturnvaluesIF::RETURN_OK) {
-      auto verifParams = VerifFailureParams(tcverif::START_FAILURE, currentPacket, result);
+      // We were not even able to retrieve the TC, so we can not retrieve any TC properties either
+      // without segfaulting
+      auto verifParams = VerifFailureParams(tcverif::START_FAILURE, 0, 0, result);
       verifParams.errorParam1 = errorParameter1;
       verifParams.errorParam2 = errorParameter2;
       psbParams.verifReporter->sendFailureReport(verifParams);
@@ -72,7 +75,7 @@ void PusServiceBase::handleRequestQueue() {
       failParams.errorParam2 = errorParameter2;
       psbParams.verifReporter->sendFailureReport(failParams);
     }
-    tcStore->deleteData(message.getStorageId());
+    psbParams.tcPool->deleteData(message.getStorageId());
     errorParameter1 = 0;
     errorParameter2 = 0;
   }
@@ -100,9 +103,16 @@ ReturnValue_t PusServiceBase::initialize() {
     }
   }
 
-  if (tcStore == nullptr) {
-    tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
-    if (tcStore == nullptr) {
+  if (psbParams.pusDistributor != nullptr) {
+    psbParams.pusDistributor = ObjectManager::instance()->get<PUSDistributorIF>(pusDistributor);
+    if (psbParams.pusDistributor != nullptr) {
+      registerService(*psbParams.pusDistributor);
+    }
+  }
+
+  if (psbParams.tcPool == nullptr) {
+    psbParams.tcPool = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
+    if (psbParams.tcPool == nullptr) {
       return ObjectManagerIF::CHILD_INIT_FAILED;
     }
   }
@@ -124,7 +134,7 @@ ReturnValue_t PusServiceBase::initializeAfterTaskCreation() {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-void PusServiceBase::setCustomTcStore(StorageManagerIF* tcStore_) { tcStore = tcStore_; }
+void PusServiceBase::setCustomTcStore(StorageManagerIF* tcPool) { psbParams.tcPool = tcPool; }
 
 void PusServiceBase::setCustomErrorReporter(InternalErrorReporterIF* errReporter_) {
   psbParams.errReporter = errReporter_;

src/fsfw/tmtcservices/PusServiceBase.h

@@ -56,6 +56,19 @@ struct PsbParams {
    * @objects::INTERNAL_ERROR_REPORTER
    */
   InternalErrorReporterIF* errReporter = nullptr;
+  /**
+   * The storage manager which will be used to retrieve any TC packet using the store ID
+   * received via a message. If this is not set, the class will attempt to find a suitable global
+   * object with the ID @objects::TC_STORE
+   */
+  StorageManagerIF* tcPool = nullptr;
+  /**
+   * Usually, packets are sent via a dedicated PUS distributor. If this distributor is set,
+   * the PUS service will register itself there. Otherwise, the base class will try to find
+   * a suitable global distributor with the static ID @PusServiceBase::pusDistributor and
+   * register itself at that object.
+   */
+  PUSDistributorIF* pusDistributor = nullptr;
 };
 
 /**
@@ -200,10 +213,10 @@ class PusServiceBase : public ExecutableObjectIF,
    * It is deleted after handleRequest was executed.
    */
   PusTcReader currentPacket;
-  StorageManagerIF* tcStore = nullptr;
   bool ownedQueue = true;
 
   static object_id_t packetDestination;
+  static object_id_t pusDistributor;
   VerifSuccessParams successParams;
 
  private:

src/fsfw/tmtcservices/VerificationReporter.cpp

@@ -1,8 +1,11 @@
 #include "fsfw/tmtcservices/VerificationReporter.h"
 
+#include "fsfw/objectmanager.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/tmtcservices/PusVerificationReport.h"
 
+object_id_t VerificationReporter::DEFAULT_RECEIVER = objects::PUS_SERVICE_1_VERIFICATION;
+
 VerificationReporter::VerificationReporter(AcceptsVerifyMessageIF* receiver, object_id_t objectId)
     : SystemObject(objectId) {
   if (receiver != nullptr) {
@@ -42,3 +45,26 @@ ReturnValue_t VerificationReporter::sendSuccessReport(VerifSuccessParams params)
   }
   return status;
 }
+
+ReturnValue_t VerificationReporter::initialize() {
+  if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
+    auto* receiver = ObjectManager::instance()->get<AcceptsVerifyMessageIF>(DEFAULT_RECEIVER);
+    if (receiver != nullptr) {
+      acknowledgeQueue = receiver->getVerificationQueue();
+    } else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+      sif::error
+          << "Could not find a suitable verification message receiver. Please ensure that it is set"
+             " via the constructor or creating a global one with the ID "
+             "VerificationReporter::DEFAULT_RECEIVER"
+          << std::endl;
+#else
+      sif::printError(
+          "Could not find a suitable verification message receiver. Please ensure "
+          "that it is set via the constructor or creating a global one with the ID "
+          "VerificationReporter::DEFAULT_RECEIVER\n");
+#endif
+    }
+  }
+  return SystemObject::initialize();
+}

src/fsfw/tmtcservices/VerificationReporter.h

@@ -33,6 +33,9 @@ class VerificationReporter : public SystemObject, public VerificationReporterIF
 
   ReturnValue_t sendFailureReport(VerifFailureParams params) override;
 
+  static object_id_t DEFAULT_RECEIVER;
+  ReturnValue_t initialize() override;
+
  private:
   MessageQueueId_t acknowledgeQueue;
 };

src/fsfw/tmtcservices/tcHelpers.cpp

@@ -1,10 +1,10 @@
 #include "tcHelpers.h"
 
-ReturnValue_t tc::prepareTcReader(StorageManagerIF *tcStore, store_address_t storeId,
+ReturnValue_t tc::prepareTcReader(StorageManagerIF &tcStore, store_address_t storeId,
                                   PusTcReader &tcReader) {
   const uint8_t *dataPtr;
   size_t dataLen = 0;
-  ReturnValue_t result = tcStore->getData(storeId, &dataPtr, &dataLen);
+  ReturnValue_t result = tcStore.getData(storeId, &dataPtr, &dataLen);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }

src/fsfw/tmtcservices/tcHelpers.h

@@ -7,7 +7,7 @@
 
 namespace tc {
 
-ReturnValue_t prepareTcReader(StorageManagerIF* tcStore, store_address_t storeId,
+ReturnValue_t prepareTcReader(StorageManagerIF& tcStore, store_address_t storeId,
                               PusTcReader& tcReader);
 
 }  // namespace tc