a lot of refactoring

CMakeLists.txt

@@ -133,14 +133,7 @@ option(FSFW_ADD_SGP4_PROPAGATOR "Add SGP4 propagator code" OFF)
 set(FSFW_TEST_TGT fsfw-tests)
 set(FSFW_DUMMY_TGT fsfw-dummy)
 
-add_library(
-  ${LIB_FSFW_NAME}
-  src/fsfw/tmtcpacket/SpacePacketIF.h
-  src/fsfw/tmtcpacket/pus/tc/PusTcCreator.h
-  src/fsfw/tmtcpacket/pus/tc/PusTcCreator.cpp
-  src/fsfw/tmtcpacket/pus/tc/PusTcIF.h
-  src/fsfw/tmtcpacket/SpacePacketCreator.h
-  src/fsfw/tmtcpacket/SpacePacketCreator.cpp)
+add_library(${LIB_FSFW_NAME})
 
 if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
   set_property(TARGET ${LIB_FSFW_NAME} PROPERTY INTERPROCEDURAL_OPTIMIZATION
@@ -175,7 +168,7 @@ if(FSFW_BUILD_TESTS)
   configure_file(unittests/testcfg/TestsConfig.h.in tests/TestsConfig.h)
 
   project(${FSFW_TEST_TGT} CXX C)
-  add_executable(${FSFW_TEST_TGT} unittests/tmtcpacket/testCcsdsReader.cpp)
+  add_executable(${FSFW_TEST_TGT})
   if(IPO_SUPPORTED AND FSFW_ENABLE_IPO)
     set_property(TARGET ${FSFW_TEST_TGT} PROPERTY INTERPROCEDURAL_OPTIMIZATION
                                                   TRUE)

src/fsfw/cfdp/CFDPHandler.h

@@ -45,7 +45,7 @@ class CFDPHandler : public ExecutableObjectIF,
    * The current CFDP packet to be processed.
    * It is deleted after handleRequest was executed.
    */
-  CFDPPacketStored currentPacket;
+  CfdpPacketStored currentPacket;
 
   static object_id_t packetSource;
 

src/fsfw/internalerror/InternalErrorReporterIF.h

@@ -12,7 +12,7 @@
  */
 class InternalErrorReporterIF {
  public:
-  virtual ~InternalErrorReporterIF() {}
+  virtual ~InternalErrorReporterIF() = default;
   /**
    * @brief Function to be called if a message queue could not be sent.
    * @details OSAL Implementations should call this function to indicate that

src/fsfw/pus/Service9TimeManagement.cpp

@@ -25,7 +25,7 @@ ReturnValue_t Service9TimeManagement::handleRequest(uint8_t subservice) {
 
 ReturnValue_t Service9TimeManagement::setTime() {
   Clock::TimeOfDay_t timeToSet;
-  TimePacket timePacket(currentPacket.getApplicationData(), currentPacket.getApplicationDataSize());
+  TimePacket timePacket(currentPacket.getUserData(), currentPacket.getUserDataSize());
   ReturnValue_t result =
       CCSDSTime::convertFromCcsds(&timeToSet, timePacket.getTime(), timePacket.getTimeSize());
   if (result != RETURN_OK) {

src/fsfw/returnvalues/FwClassIds.h

@@ -34,7 +34,7 @@ enum : uint8_t {
   FIFO_CLASS,                     // FF
   MESSAGE_PROXY,                  // MQP
   TRIPLE_REDUNDACY_CHECK,         // TRC
-  TC_PACKET_CHECK,                // TCC
+  PACKET_CHECK,                   // TCC
   PACKET_DISTRIBUTION,            // TCD
   ACCEPTS_TELECOMMANDS_IF,        // PUS
   DEVICE_SERVICE_BASE,            // DSB

src/fsfw/tcdistribution/CCSDSDistributor.cpp

@@ -40,7 +40,7 @@ TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
 #endif
     return queueMap.end();
   }
-  SpacePacketReader currentPacket(packet);
+  SpacePacketReader currentPacket(packet, size);
 
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && CCSDS_DISTRIBUTOR_DEBUGGING == 1
   sif::info << "CCSDSDistributor::selectDestination has packet with APID " << std::hex

src/fsfw/tcdistribution/CCSDSDistributorIF.h

@@ -34,7 +34,7 @@ class CCSDSDistributorIF {
   /**
    * The empty virtual destructor.
    */
-  virtual ~CCSDSDistributorIF() {}
+  virtual ~CCSDSDistributorIF() = default;
 };
 
 #endif /* FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_ */

src/fsfw/tcdistribution/CFDPDistributor.cpp

@@ -2,7 +2,7 @@
 
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/tcdistribution/CCSDSDistributorIF.h"
-#include "fsfw/tmtcpacket/cfdp/CFDPPacketStored.h"
+#include "fsfw/tmtcpacket/cfdp/CfdpPacketStored.h"
 
 #ifndef FSFW_CFDP_DISTRIBUTOR_DEBUGGING
 #define FSFW_CFDP_DISTRIBUTOR_DEBUGGING 1
@@ -16,7 +16,7 @@ CFDPDistributor::CFDPDistributor(uint16_t setApid, object_id_t setObjectId,
       tcStatus(RETURN_FAILED),
       packetSource(setPacketSource) {}
 
-CFDPDistributor::~CFDPDistributor() {}
+CFDPDistributor::~CFDPDistributor() = default;
 
 CFDPDistributor::TcMqMapIter CFDPDistributor::selectDestination() {
 #if FSFW_CFDP_DISTRIBUTOR_DEBUGGING == 1
@@ -29,13 +29,13 @@ CFDPDistributor::TcMqMapIter CFDPDistributor::selectDestination() {
                   storeId.packetIndex);
 #endif
 #endif
-  TcMqMapIter queueMapIt = this->queueMap.end();
+  auto queueMapIt = this->queueMap.end();
   if (this->currentPacket == nullptr) {
     return queueMapIt;
   }
   this->currentPacket->setStoreAddress(this->currentMessage.getStorageId());
-  if (currentPacket->getWholeData() != nullptr) {
-    tcStatus = checker.checkPacket(currentPacket);
+  if (currentPacket->getFullData() != nullptr) {
+    tcStatus = checker.checkPacket(currentPacket, currentPacket->getFullPacketLen());
     if (tcStatus != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -121,14 +121,13 @@ MessageQueueId_t CFDPDistributor::getRequestQueue() { return tcQueue->getId(); }
 uint16_t CFDPDistributor::getIdentifier() { return this->apid; }
 
 ReturnValue_t CFDPDistributor::initialize() {
-  currentPacket = new CFDPPacketStored();
+  currentPacket = new CfdpPacketStored();
   if (currentPacket == nullptr) {
     // Should not happen, memory allocation failed!
     return ObjectManagerIF::CHILD_INIT_FAILED;
   }
 
-  CCSDSDistributorIF* ccsdsDistributor =
-      ObjectManager::instance()->get<CCSDSDistributorIF>(packetSource);
+  auto* ccsdsDistributor = ObjectManager::instance()->get<CCSDSDistributorIF>(packetSource);
   if (ccsdsDistributor == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "CFDPDistributor::initialize: Packet source invalid" << std::endl;

src/fsfw/tcdistribution/CFDPDistributor.h

@@ -1,10 +1,10 @@
 #ifndef FSFW_TCDISTRIBUTION_CFDPDISTRIBUTOR_H_
 #define FSFW_TCDISTRIBUTION_CFDPDISTRIBUTOR_H_
 
-#include <fsfw/tcdistribution/TcPacketCheckCFDP.h>
+#include <fsfw/tcdistribution/CfdpPacketChecker.h>
 
 #include "../returnvalues/HasReturnvaluesIF.h"
-#include "../tmtcpacket/cfdp/CFDPPacketStored.h"
+#include "../tmtcpacket/cfdp/CfdpPacketStored.h"
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../tmtcservices/VerificationReporter.h"
 #include "CFDPDistributorIF.h"
@@ -31,7 +31,7 @@ class CFDPDistributor : public TcDistributor,
   /**
    * The destructor is empty.
    */
-  virtual ~CFDPDistributor();
+  ~CFDPDistributor() override;
   ReturnValue_t registerHandler(AcceptsTelecommandsIF* handler) override;
   MessageQueueId_t getRequestQueue() override;
   ReturnValue_t initialize() override;
@@ -42,8 +42,8 @@ class CFDPDistributor : public TcDistributor,
   /**
    * The currently handled packet is stored here.
    */
-  CFDPPacketStored* currentPacket = nullptr;
-  TcPacketCheckCFDP checker;
+  CfdpPacketStored* currentPacket = nullptr;
+  CfdpPacketChecker checker;
   /**
    * With this variable, the current check status is stored to generate
    * acceptance messages later.

src/fsfw/tcdistribution/CFDPDistributorIF.h

@@ -13,7 +13,7 @@ class CFDPDistributorIF {
   /**
    * The empty virtual destructor.
    */
-  virtual ~CFDPDistributorIF() {}
+  virtual ~CFDPDistributorIF() = default;
   /**
    * With this method, Handlers can register themselves at the CFDP Distributor.
    * @param handler A pointer to the registering Handler.

src/fsfw/tcdistribution/CMakeLists.txt

@@ -1,4 +1,9 @@
 target_sources(
   ${LIB_FSFW_NAME}
-  PRIVATE CCSDSDistributor.cpp PUSDistributor.cpp TcDistributor.cpp
-          TcPacketCheckPUS.cpp TcPacketCheckCFDP.cpp CFDPDistributor.cpp)
+  PRIVATE CCSDSDistributor.cpp
+          PusDistributor.cpp
+          TcDistributor.cpp
+          PusPacketChecker.cpp
+          TcPacketCheckCFDP.cpp
+          CFDPDistributor.cpp
+          CcsdsPacketCheckerBase.cpp)

src/fsfw/tcdistribution/CcsdsPacketCheckIF.h

@@ -1,7 +1,9 @@
 #ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKIF_H_
 #define FSFW_TCDISTRIBUTION_TCPACKETCHECKIF_H_
 
-#include "../returnvalues/HasReturnvaluesIF.h"
+#include <cstddef>
+
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
 class SpacePacketReader;
 
@@ -9,22 +11,22 @@ class SpacePacketReader;
  * This interface is used by PacketCheckers for PUS packets and CFDP packets .
  * @ingroup tc_distribution
  */
-class TcPacketCheckIF {
+class CcsdsPacketCheckIF {
  public:
   /**
    * The empty virtual destructor.
    */
-  virtual ~TcPacketCheckIF() {}
+  virtual ~CcsdsPacketCheckIF() = default;
 
   /**
    * This is the actual method to formally check a certain Packet.
    * The packet's Application Data can not be checked here.
    * @param current_packet The packet to check
    * @return	- @c RETURN_OK on success.
-   * 			- @c INCORRECT_CHECKSUM if checksum is invalid.
-   * 			- @c ILLEGAL_APID if APID does not match.
+   *            - @c INCORRECT_CHECKSUM if checksum is invalid.
+   * 		- @c ILLEGAL_APID if APID does not match.
    */
-  virtual ReturnValue_t checkPacket(SpacePacketReader* currentPacket) = 0;
+  virtual ReturnValue_t checkPacket(SpacePacketReader* currentPacket, size_t packetLen) = 0;
 };
 
 #endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKIF_H_ */

src/fsfw/tcdistribution/CcsdsPacketCheckerBase.cpp

@@ -0,0 +1,22 @@
+#include "CcsdsPacketCheckerBase.h"
+
+#include "fsfw/tcdistribution/definitions.h"
+#include "fsfw/tmtcpacket/SpacePacketReader.h"
+
+CcsdsPacketCheckerBase::CcsdsPacketCheckerBase(uint16_t apid, ccsds::PacketType packetType_,
+                                               uint8_t ccsdsVersion_)
+    : apid(apid), packetType(packetType_), ccsdsVersion(ccsdsVersion_) {}
+
+ReturnValue_t CcsdsPacketCheckerBase::checkPacket(SpacePacketReader* currentPacket,
+                                                  size_t packetLen) {
+  if (currentPacket->getApid() != apid) {
+    return tcdistrib::INVALID_APID;
+  }
+  if (currentPacket->getVersion() != ccsdsVersion) {
+    return tcdistrib::INVALID_CCSDS_VERSION;
+  }
+  if (currentPacket->getPacketType() != packetType) {
+    return tcdistrib::INVALID_PACKET_TYPE;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
+}

src/fsfw/tcdistribution/CcsdsPacketCheckerBase.h

@@ -0,0 +1,17 @@
+#ifndef FSFW_TESTS_CCSDSPACKETCHECKERBASE_H
+#define FSFW_TESTS_CCSDSPACKETCHECKERBASE_H
+
+#include "CcsdsPacketCheckIF.h"
+#include "fsfw/tmtcpacket/SpacePacketIF.h"
+
+class CcsdsPacketCheckerBase : public CcsdsPacketCheckIF, public HasReturnvaluesIF {
+ public:
+  CcsdsPacketCheckerBase(uint16_t apid, ccsds::PacketType packetType, uint8_t ccsdsVersion = 0b000);
+  ReturnValue_t checkPacket(SpacePacketReader* currentPacket, size_t packetLen) override;
+
+ protected:
+  uint16_t apid;
+  ccsds::PacketType packetType;
+  uint8_t ccsdsVersion;
+};
+#endif  // FSFW_TESTS_CCSDSPACKETCHECKERBASE_H

src/fsfw/tcdistribution/CfdpPacketChecker.h

@@ -1,16 +1,16 @@
 #ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKCFDP_H_
 #define FSFW_TCDISTRIBUTION_TCPACKETCHECKCFDP_H_
 
-#include "TcPacketCheckIF.h"
+#include "CcsdsPacketCheckIF.h"
 #include "fsfw/FSFW.h"
 
-class CFDPPacketStored;
+class CfdpPacketStored;
 
 /**
  * This class performs a formal packet check for incoming CFDP Packets.
  * @ingroup tc_distribution
  */
-class TcPacketCheckCFDP : public TcPacketCheckIF, public HasReturnvaluesIF {
+class CfdpPacketChecker : public CcsdsPacketCheckIF, public HasReturnvaluesIF {
  protected:
   /**
    * The packet id each correct packet should have.
@@ -23,11 +23,11 @@ class TcPacketCheckCFDP : public TcPacketCheckIF, public HasReturnvaluesIF {
    * The constructor only sets the APID attribute.
    * @param set_apid The APID to set.
    */
-  TcPacketCheckCFDP(uint16_t setApid);
+  explicit CfdpPacketChecker(uint16_t setApid);
 
-  ReturnValue_t checkPacket(SpacePacketReader* currentPacket) override;
+  ReturnValue_t checkPacket(SpacePacketReader* currentPacket, size_t packetLen) override;
 
-  uint16_t getApid() const;
+  [[nodiscard]] uint16_t getApid() const;
 };
 
 #endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKCFDP_H_ */

src/fsfw/tcdistribution/PusDistributor.cpp

@@ -1,23 +1,25 @@
-#include "fsfw/tcdistribution/PUSDistributor.h"
+#include "fsfw/tcdistribution/PusDistributor.h"
 
 #include "fsfw/objectmanager/ObjectManager.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 #include "fsfw/tcdistribution/CCSDSDistributorIF.h"
+#include "fsfw/tmtcpacket/PacketStorageHelper.h"
 #include "fsfw/tmtcservices/PusVerificationReport.h"
 
 #define PUS_DISTRIBUTOR_DEBUGGING 0
 
-PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+PusDistributor::PusDistributor(StorageManagerIF* store_, uint16_t setApid, object_id_t setObjectId,
                                object_id_t setPacketSource)
     : TcDistributor(setObjectId),
-      checker(setApid),
+      store(store_),
+      checker(setApid, ccsds::PacketType::TC),
       verifyChannel(),
       tcStatus(RETURN_FAILED),
       packetSource(setPacketSource) {}
 
-PUSDistributor::~PUSDistributor() = default;
+PusDistributor::~PusDistributor() = default;
 
-PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
+PusDistributor::TcMqMapIter PusDistributor::selectDestination() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1 && PUS_DISTRIBUTOR_DEBUGGING == 1
     store_address_t storeId = this->currentMessage.getStorageId());
     sif::debug << "PUSDistributor::handlePacket received: " << storeId.poolIndex << ", "
@@ -27,9 +29,18 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
     if (this->currentPacket == nullptr) {
       return queueMapIt;
     }
-    this->currentPacket->setStoreAddress(this->currentMessage.getStorageId(), currentPacket);
-    if (currentPacket->getWholeData() != nullptr) {
-      tcStatus = checker.checkPacket(currentPacket);
+    // TODO: Need to set the data
+    const uint8_t* packetPtr = nullptr;
+    size_t packetLen = 0;
+    if (store->getData(currentMessage.getStorageId(), &packetPtr, &packetLen) !=
+        HasReturnvaluesIF::RETURN_OK) {
+      return queueMapIt;
+    }
+    reader.setData(packetPtr, packetLen);
+    // this->currentPacket->setStoreAddress(this->currentMessage.getStorageId(), currentPacket);
+    if (reader.getFullData() != nullptr) {
+      tcStatus =
+          checker.checkPacket(dynamic_cast<PacketCheckIF*>(&reader), reader.getFullPacketLen());
       if (tcStatus != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_VERBOSE_LEVEL >= 1
         const char* keyword = "unnamed error";
@@ -53,7 +64,7 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
 #endif
 #endif
       }
-      uint32_t queue_id = currentPacket->getService();
+      uint32_t queue_id = reader.getService();
       queueMapIt = this->queueMap.find(queue_id);
     } else {
       tcStatus = PACKET_LOST;
@@ -77,7 +88,7 @@ PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
     }
 }
 
-ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
+ReturnValue_t PusDistributor::registerService(AcceptsTelecommandsIF* service) {
   uint16_t serviceId = service->getIdentifier();
 #if PUS_DISTRIBUTOR_DEBUGGING == 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -103,29 +114,27 @@ ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
-MessageQueueId_t PUSDistributor::getRequestQueue() { return tcQueue->getId(); }
+MessageQueueId_t PusDistributor::getRequestQueue() { return tcQueue->getId(); }
 
-ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+ReturnValue_t PusDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
   if (queueStatus != RETURN_OK) {
     tcStatus = queueStatus;
   }
   if (tcStatus != RETURN_OK) {
-    this->verifyChannel.sendFailureReport(tc_verification::ACCEPTANCE_FAILURE, currentPacket,
-                                          tcStatus);
+    this->verifyChannel.sendFailureReport(tc_verification::ACCEPTANCE_FAILURE, &reader, tcStatus);
     // A failed packet is deleted immediately after reporting,
     // otherwise it will block memory.
-    currentPacket->deletePacket();
+    store->deleteData(currentMessage.getStorageId());
     return RETURN_FAILED;
   } else {
-    this->verifyChannel.sendSuccessReport(tc_verification::ACCEPTANCE_SUCCESS, currentPacket);
+    this->verifyChannel.sendSuccessReport(tc_verification::ACCEPTANCE_SUCCESS, &reader);
     return RETURN_OK;
   }
 }
 
-uint16_t PUSDistributor::getIdentifier() { return checker.getApid(); }
+uint16_t PusDistributor::getIdentifier() { return checker.getApid(); }
 
-ReturnValue_t PUSDistributor::initialize() {
-  currentPacket = new TcPacketStoredPus();
+ReturnValue_t PusDistributor::initialize() {
   if (currentPacket == nullptr) {
     // Should not happen, memory allocation failed!
     return ObjectManagerIF::CHILD_INIT_FAILED;
@@ -137,7 +146,7 @@ ReturnValue_t PUSDistributor::initialize() {
     sif::error << "PUSDistributor::initialize: Packet source invalid" << std::endl;
     sif::error << " Make sure it exists and implements CCSDSDistributorIF!" << std::endl;
 #else
-    sif::printError("PUSDistributor::initialize: Packet source invalid\n");
+    sif::printError("PusDistributor::initialize: Packet source invalid\n");
     sif::printError("Make sure it exists and implements CCSDSDistributorIF\n");
 #endif
     return RETURN_FAILED;

src/fsfw/tcdistribution/PusDistributor.h

@@ -2,20 +2,22 @@
 #define FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
 
 #include "PUSDistributorIF.h"
+#include "PusPacketChecker.h"
 #include "TcDistributor.h"
-#include "TcPacketCheckPUS.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "fsfw/tmtcpacket/pus/tc.h"
 #include "fsfw/tmtcservices/AcceptsTelecommandsIF.h"
 #include "fsfw/tmtcservices/VerificationReporter.h"
 
+class PacketStorageHelper;
+
 /**
  * This class accepts PUS Telecommands and forwards them to Application
  * services. In addition, the class performs a formal packet check and
  * sends acceptance success or failure messages.
  * @ingroup tc_distribution
  */
-class PUSDistributor : public TcDistributor, public PUSDistributorIF, public AcceptsTelecommandsIF {
+class PusDistributor : public TcDistributor, public PUSDistributorIF, public AcceptsTelecommandsIF {
  public:
   /**
    * The ctor passes @c set_apid to the checker class and calls the
@@ -25,21 +27,23 @@ class PUSDistributor : public TcDistributor, public PUSDistributorIF, public Acc
    * @param setPacketSource Object ID of the source of TC packets.
    * Must implement CCSDSDistributorIF.
    */
-  PUSDistributor(uint16_t setApid, object_id_t setObjectId, object_id_t setPacketSource);
+  PusDistributor(StorageManagerIF* store, uint16_t setApid, object_id_t setObjectId,
+                 object_id_t setPacketSource);
   /**
    * The destructor is empty.
    */
-  virtual ~PUSDistributor();
+  ~PusDistributor() override;
   ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
   MessageQueueId_t getRequestQueue() override;
   ReturnValue_t initialize() override;
   uint16_t getIdentifier() override;
 
  protected:
+  StorageManagerIF* store;
   /**
    * This attribute contains the class, that performs a formal packet check.
    */
-  TcPacketCheckPUS checker;
+  PusPacketChecker checker;
   /**
    * With this class, verification messages are sent to the
    * TC Verification service.
@@ -48,7 +52,8 @@ class PUSDistributor : public TcDistributor, public PUSDistributorIF, public Acc
   /**
    * The currently handled packet is stored here.
    */
-  TcPacketStoredPus* currentPacket = nullptr;
+  PacketStorageHelper* currentPacket = nullptr;
+  PusTcReader reader;
 
   /**
    * With this variable, the current check status is stored to generate

src/fsfw/tcdistribution/PusPacketChecker.cpp

@@ -0,0 +1,44 @@
+#include "fsfw/tcdistribution/PusPacketChecker.h"
+
+#include "fsfw/globalfunctions/CRC.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/tcdistribution/definitions.h"
+#include "fsfw/tmtcpacket/pus/tc/PusTcReader.h"
+
+PusPacketChecker::PusPacketChecker(uint16_t setApid, ccsds::PacketType packetType_,
+                                   ecss::PusVersion pusVersion_)
+    : CcsdsPacketCheckerBase(setApid, packetType_), pusVersion(pusVersion_) {}
+
+ReturnValue_t PusPacketChecker::checkPacket(PacketCheckIF* pusPacket, size_t packetLen) {
+  if (pusPacket == nullptr) {
+    return RETURN_FAILED;
+  }
+  // Other primary header fields are checked by base class
+  if (not pusPacket->hasSecHeader()) {
+    return tcdistrib::INVALID_SEC_HEADER_FIELD;
+  }
+  uint16_t calculated_crc =
+      CRC::crc16ccitt(pusPacket->getFullData(), pusPacket->getFullPacketLen());
+  if (calculated_crc != 0) {
+    return tcdistrib::INCORRECT_CHECKSUM;
+  }
+
+  // This assumes that the getFullPacketLen version uses the space packet data length field
+  if (pusPacket->getFullPacketLen() != packetLen) {
+    return tcdistrib::INCOMPLETE_PACKET;
+  }
+  if (pusPacket->getPusVersion() != pusVersion) {
+    return tcdistrib::INVALID_PUS_VERSION;
+  }
+  return RETURN_OK;
+}
+
+uint16_t PusPacketChecker::getApid() const { return apid; }
+
+ReturnValue_t PusPacketChecker::checkPacket(SpacePacketReader* currentPacket, size_t packetLen) {
+  ReturnValue_t result = CcsdsPacketCheckerBase::checkPacket(currentPacket, packetLen);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  return checkPacket(dynamic_cast<PacketCheckIF*>(currentPacket), packetLen);
+}

src/fsfw/tcdistribution/PusPacketChecker.h

@@ -0,0 +1,38 @@
+#ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_
+#define FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_
+
+#include "CcsdsPacketCheckIF.h"
+#include "CcsdsPacketCheckerBase.h"
+#include "fsfw/FSFW.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/tmtcpacket/pus/definitions.h"
+#include "fsfw/tmtcservices/PusVerificationReport.h"
+
+class PacketCheckIF : public ReadablePacketIF, public PusIF {};
+
+/**
+ * This class performs a formal packet check for incoming PUS Telecommand Packets.
+ * Currently, it only checks if the APID and CRC are correct.
+ * @ingroup tc_distribution
+ */
+class PusPacketChecker : public CcsdsPacketCheckerBase {
+ public:
+  /**
+   * The constructor only sets the APID attribute.
+   * @param set_apid The APID to set.
+   */
+  PusPacketChecker(uint16_t setApid, ccsds::PacketType packetType,
+                   ecss::PusVersion = ecss::PusVersion::PUS_C);
+
+  ReturnValue_t checkPacket(PacketCheckIF* currentPacket, size_t packetLen);
+
+  [[nodiscard]] uint16_t getApid() const;
+
+ protected:
+  ecss::PusVersion pusVersion;
+
+ private:
+  ReturnValue_t checkPacket(SpacePacketReader* currentPacket, size_t packetLen) override;
+};
+
+#endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_ */

src/fsfw/tcdistribution/TcDistributor.cpp

@@ -24,7 +24,7 @@ ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
 }
 
 ReturnValue_t TcDistributor::handlePacket() {
-  TcMqMapIter queueMapIt = this->selectDestination();
+  auto queueMapIt = this->selectDestination();
   ReturnValue_t returnValue = RETURN_FAILED;
   if (queueMapIt != this->queueMap.end()) {
     returnValue = this->tcQueue->sendMessage(queueMapIt->second, &this->currentMessage);

src/fsfw/tcdistribution/TcPacketCheckCFDP.cpp

@@ -1,9 +1,10 @@
-#include "fsfw/tcdistribution/TcPacketCheckCFDP.h"
+#include "fsfw/tcdistribution/CfdpPacketChecker.h"
+#include "fsfw/tmtcpacket/cfdp/CfdpPacketStored.h"
 
-#include "fsfw/tmtcpacket/cfdp/CFDPPacketStored.h"
+CfdpPacketChecker::CfdpPacketChecker(uint16_t setApid) : apid(setApid) {}
 
-TcPacketCheckCFDP::TcPacketCheckCFDP(uint16_t setApid) : apid(setApid) {}
+ReturnValue_t CfdpPacketChecker::checkPacket(SpacePacketReader* currentPacket, size_t packetLen) {
+  return RETURN_OK;
+}
 
-ReturnValue_t TcPacketCheckCFDP::checkPacket(SpacePacketReader* currentPacket) { return RETURN_OK; }
-
-uint16_t TcPacketCheckCFDP::getApid() const { return apid; }
+uint16_t CfdpPacketChecker::getApid() const { return apid; }

src/fsfw/tcdistribution/TcPacketCheckPUS.cpp

@@ -1,44 +0,0 @@
-#include "fsfw/tcdistribution/TcPacketCheckPUS.h"
-
-#include "fsfw/globalfunctions/CRC.h"
-#include "fsfw/serviceinterface/ServiceInterface.h"
-#include "fsfw/storagemanager/StorageManagerIF.h"
-#include "fsfw/tmtcpacket/pus/tc/PusTcReader.h"
-#include "fsfw/tmtcpacket/pus/tc/TcPacketStoredBase.h"
-#include "fsfw/tmtcpacket/pus/tc/TcPacketStoredPus.h"
-#include "fsfw/tmtcservices/VerificationCodes.h"
-
-TcPacketCheckPUS::TcPacketCheckPUS(uint16_t setApid) : apid(setApid) {}
-
-ReturnValue_t TcPacketCheckPUS::checkPacket(SpacePacketReader* currentPacket) {
-  auto* storedPacket = dynamic_cast<TcPacketStoredBase*>(currentPacket);
-  auto* tcPacketBase = dynamic_cast<TcPacketPusBase*>(currentPacket);
-  if (tcPacketBase == nullptr or storedPacket == nullptr) {
-    return RETURN_FAILED;
-  }
-  uint16_t calculated_crc =
-      CRC::crc16ccitt(tcPacketBase->getWholeData(), tcPacketBase->getFullSize());
-  if (calculated_crc != 0) {
-    return INCORRECT_CHECKSUM;
-  }
-  bool condition = (not tcPacketBase->hasSecHeader()) or
-                   (tcPacketBase->getVersion() != CCSDS_VERSION_NUMBER) or
-                   (not tcPacketBase->isTc());
-  if (condition) {
-    return INCORRECT_PRIMARY_HEADER;
-  }
-  if (tcPacketBase->getApid() != this->apid) return ILLEGAL_APID;
-
-  if (not storedPacket->isSizeCorrect()) {
-    return INCOMPLETE_PACKET;
-  }
-
-  condition = (tcPacketBase->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
-              (tcPacketBase->getPusVersionNumber() != PUS_VERSION_NUMBER);
-  if (condition) {
-    return INCORRECT_SECONDARY_HEADER;
-  }
-  return RETURN_OK;
-}
-
-uint16_t TcPacketCheckPUS::getApid() const { return apid; }

src/fsfw/tcdistribution/TcPacketCheckPUS.h

@@ -1,61 +0,0 @@
-#ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_
-#define FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_
-
-#include "TcPacketCheckIF.h"
-#include "fsfw/FSFW.h"
-#include "fsfw/returnvalues/HasReturnvaluesIF.h"
-#include "fsfw/tmtcservices/PusVerificationReport.h"
-
-class TcPacketStoredBase;
-
-/**
- * This class performs a formal packet check for incoming PUS Telecommand Packets.
- * Currently, it only checks if the APID and CRC are correct.
- * @ingroup tc_distribution
- */
-class TcPacketCheckPUS : public TcPacketCheckIF, public HasReturnvaluesIF {
- protected:
-  /**
-   * Describes the version number a packet must have to pass.
-   */
-  static constexpr uint8_t CCSDS_VERSION_NUMBER = 0;
-  /**
-   * Describes the secondary header a packet must have to pass.
-   */
-  static constexpr uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
-  /**
-   * Describes the TC Packet PUS Version Number a packet must have to pass.
-   */
-#if FSFW_USE_PUS_C_TELECOMMANDS == 1
-  static constexpr uint8_t PUS_VERSION_NUMBER = 2;
-#else
-  static constexpr uint8_t PUS_VERSION_NUMBER = 1;
-#endif
-
-  /**
-   * The packet id each correct packet should have.
-   * It is composed of the APID and some static fields.
-   */
-  uint16_t apid;
-
- public:
-  static const uint8_t INTERFACE_ID = CLASS_ID::TC_PACKET_CHECK;
-  static const ReturnValue_t ILLEGAL_APID = MAKE_RETURN_CODE(0);
-  static const ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE(1);
-  static const ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE(2);
-  static const ReturnValue_t ILLEGAL_PACKET_TYPE = MAKE_RETURN_CODE(3);
-  static const ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE(4);
-  static const ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE(5);
-  static const ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE(6);
-  /**
-   * The constructor only sets the APID attribute.
-   * @param set_apid The APID to set.
-   */
-  TcPacketCheckPUS(uint16_t setApid);
-
-  ReturnValue_t checkPacket(SpacePacketReader* currentPacket) override;
-
-  uint16_t getApid() const;
-};
-
-#endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECKPUS_H_ */

src/fsfw/tcdistribution/definitions.h

@@ -0,0 +1,24 @@
+#ifndef FSFW_TMTCPACKET_DEFINITIONS_H
+#define FSFW_TMTCPACKET_DEFINITIONS_H
+
+#include <cstdint>
+
+#include "fsfw/returnvalues/FwClassIds.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+
+namespace tcdistrib {
+static const uint8_t INTERFACE_ID = CLASS_ID::PACKET_CHECK;
+static constexpr ReturnValue_t INVALID_CCSDS_VERSION = MAKE_RETURN_CODE(0);
+static constexpr ReturnValue_t INVALID_APID = MAKE_RETURN_CODE(1);
+static constexpr ReturnValue_t INVALID_PACKET_TYPE = MAKE_RETURN_CODE(2);
+static constexpr ReturnValue_t INVALID_SEC_HEADER_FIELD = MAKE_RETURN_CODE(3);
+static constexpr ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE(4);
+
+static constexpr ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE(5);
+static constexpr ReturnValue_t INVALID_PUS_VERSION = MAKE_RETURN_CODE(6);
+static constexpr ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE(7);
+static constexpr ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE(8);
+static constexpr ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE(9);
+
+};      // namespace tcdistrib
+#endif  // FSFW_TMTCPACKET_DEFINITIONS_H

src/fsfw/tmstorage/TmStorePackets.h

@@ -8,7 +8,7 @@
 #include "fsfw/serialize/SerializeElement.h"
 #include "fsfw/timemanager/CCSDSTime.h"
 #include "fsfw/timemanager/TimeStamperIF.h"
-#include "fsfw/tmtcpacket/pus/tm/TmPacketMinimal.h"
+#include "fsfw/tmtcpacket/pus/tm/PusTmMinimal.h"
 #include "tmStorageConf.h"
 
 class ServiceSubservice : public SerialLinkedListAdapter<SerializeIF> {

src/fsfw/tmtcpacket/CMakeLists.txt

@@ -1,4 +1,6 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE SpacePacketReader.cpp)
+target_sources(
+  ${LIB_FSFW_NAME} PRIVATE SpacePacketReader.cpp SpacePacketCreator.cpp
+                           PacketStorageHelper.cpp)
 
 add_subdirectory(cfdp)
 add_subdirectory(packetmatcher)

src/fsfw/tmtcpacket/PacketStorageHelper.cpp

@@ -0,0 +1,25 @@
+#include "PacketStorageHelper.h"
+
+#include <cstring>
+
+#include "fsfw/serialize.h"
+#include "fsfw/serviceinterface/ServiceInterface.h"
+#include "fsfw/storagemanager/StorageManagerIF.h"
+
+PacketStorageHelper::PacketStorageHelper(StorageManagerIF* store_,
+                                         SerializeIF::Endianness endianness_)
+    : store(store_), endianness(endianness_) {}
+
+ReturnValue_t PacketStorageHelper::addPacket(SerializeIF* packet, store_address_t& storeId) {
+  uint8_t* ptr = nullptr;
+  size_t serLen = 0;
+  ReturnValue_t result = store->getFreeElement(&storeId, packet->getSerializedSize(), &ptr);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  return packet->serialize(&ptr, &serLen, packet->getSerializedSize(), endianness);
+}
+
+ReturnValue_t PacketStorageHelper::deletePacket(store_address_t storeId) {
+  return store->deleteData(storeId);
+}

src/fsfw/tmtcpacket/PacketStorageHelper.h

@@ -0,0 +1,63 @@
+#ifndef FSFW_TMTCPACKET_PUS_TCPACKETSTOREDPUSA_H_
+#define FSFW_TMTCPACKET_PUS_TCPACKETSTOREDPUSA_H_
+
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/serialize.h"
+#include "fsfw/storagemanager/storeAddress.h"
+
+class StorageManagerIF;
+
+class PacketStorageHelper {
+ public:
+  explicit PacketStorageHelper(StorageManagerIF* store, SerializeIF::Endianness endianness);
+
+  ReturnValue_t addPacket(SerializeIF* packet, store_address_t& storeId);
+  ReturnValue_t deletePacket(store_address_t storeId);
+
+ private:
+  StorageManagerIF* store;
+  SerializeIF::Endianness endianness;
+};
+// class TcPacketStoredPus : public TcPacketStoredBase, public TcPacketPus {
+//  public:
+//   /**
+//    * With this constructor, new space is allocated in the packet store and
+//    * a new PUS Telecommand Packet is created there.
+//    * Packet Application Data passed in data is copied into the packet.
+//    * @param apid          Sets the packet's APID field.
+//    * @param service       Sets the packet's Service ID field.
+//    *                      This specifies the destination service.
+//    * @param subservice    Sets the packet's Service Subtype field.
+//    *                      This specifies the destination sub-service.
+//    * @param sequence_count Sets the packet's Source Sequence Count field.
+//    * @param data      The data to be copied to the Application Data Field.
+//    * @param size      The amount of data to be copied.
+//    * @param ack           Set's the packet's Ack field, which specifies
+//    *                      number of verification packets returned
+//    *                      for this command.
+//    */
+//   TcPacketStoredPus(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t sequence_count =
+//   0,
+//                     const uint8_t* data = nullptr, size_t size = 0,
+//                     uint8_t ack = TcPacketPusBase::ACK_ALL);
+//   /**
+//    * Create stored packet with existing data.
+//    * @param data
+//    * @param size
+//    */
+//   TcPacketStoredPus(const uint8_t* data, size_t size);
+//   /**
+//    * Create stored packet from existing packet in store
+//    * @param setAddress
+//    */
+//   TcPacketStoredPus(store_address_t setAddress);
+//   TcPacketStoredPus();
+//
+//   ReturnValue_t deletePacket() override;
+//   TcPacketPusBase* getPacketBase();
+//
+//  private:
+//   bool isSizeCorrect() override;
+// };
+
+#endif /* FSFW_TMTCPACKET_PUS_TCPACKETSTOREDPUSA_H_ */

src/fsfw/tmtcpacket/ReadablePacketIF.h

@@ -0,0 +1,13 @@
+#ifndef FSFW_TMTCPACKET_SPACEPACKETREADERIF_H
+#define FSFW_TMTCPACKET_SPACEPACKETREADERIF_H
+
+#include "SpacePacketIF.h"
+
+class ReadablePacketIF {
+ public:
+  /**
+   * This method returns a raw uint8_t pointer to the readable data
+   */
+  virtual const uint8_t* getFullData() = 0;
+};
+#endif  // FSFW_TMTCPACKET_SPACEPACKETREADERIF_H

src/fsfw/tmtcpacket/RedirectableDataPointerIF.h

@@ -25,9 +25,9 @@ class RedirectableDataPointerIF {
    *  - RETURN_OK if the pointer was set successfully
    *  - RETURN_FAILED on general error of if the maximum size is too small
    */
-  virtual ReturnValue_t setData(uint8_t* dataPtr, size_t maxSize, void* args) = 0;
-  virtual ReturnValue_t setData(uint8_t* dataPtr, size_t maxSize) {
-    return setData(dataPtr, maxSize, nullptr);
+  virtual ReturnValue_t setData(uint8_t* dataPtr, size_t size, void* args) = 0;
+  virtual ReturnValue_t setData(uint8_t* dataPtr, size_t size) {
+    return setData(dataPtr, size, nullptr);
   }
 
  private:

src/fsfw/tmtcpacket/SpacePacketCreator.cpp

@@ -2,44 +2,32 @@
 
 #include "fsfw/serialize/SerializeAdapter.h"
 
-SpacePacketCreator::SpacePacketCreator(PacketId packetId_, PacketSeqCtrl psc_, uint16_t dataLen_,
-                                       uint8_t version_)
-    : packetId(packetId_), packetSeqCtrl(psc_) {
-  dataLen = dataLen_;
-  version = version_;
+SpacePacketCreator::SpacePacketCreator(SpacePacketParams &params_) : params(params_) {
   checkFieldValidity();
 }
 
-SpacePacketCreator::SpacePacketCreator(ccsds::PacketType packetType, bool secHeaderFlag,
-                                       uint16_t apid, ccsds::SequenceFlags seqFlags,
-                                       uint16_t seqCount, uint16_t dataLen_, uint8_t version_)
-    : SpacePacketCreator(PacketId(packetType, secHeaderFlag, apid),
-                         PacketSeqCtrl(seqFlags, seqCount), dataLen_, version_) {
-  version = version_;
-  dataLen = dataLen_;
-}
-
-uint16_t SpacePacketCreator::getPacketId() const { return packetId.raw(); }
-uint16_t SpacePacketCreator::getPacketSeqCtrl() const { return packetSeqCtrl.raw(); }
-uint16_t SpacePacketCreator::getPacketDataLen() const { return dataLen; }
+uint16_t SpacePacketCreator::getPacketId() const { return params.packetId.raw(); }
+uint16_t SpacePacketCreator::getPacketSeqCtrl() const { return params.packetSeqCtrl.raw(); }
+uint16_t SpacePacketCreator::getPacketDataLen() const { return params.dataLen; }
 
 ReturnValue_t SpacePacketCreator::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
                                             SerializeIF::Endianness streamEndianness) const {
   if (not isValid()) {
     return HasReturnvaluesIF::RETURN_FAILED;
   }
-  uint16_t packetIdAndVersion = (static_cast<uint16_t>(version) << 13) | packetId.raw();
+  uint16_t packetIdAndVersion =
+      (static_cast<uint16_t>(params.version) << 13) | params.packetId.raw();
   ReturnValue_t result =
       SerializeAdapter::serialize(&packetIdAndVersion, buffer, size, maxSize, streamEndianness);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  uint16_t pscRaw = packetSeqCtrl.raw();
+  uint16_t pscRaw = params.packetSeqCtrl.raw();
   result = SerializeAdapter::serialize(&pscRaw, buffer, size, maxSize, streamEndianness);
   if (result != HasReturnvaluesIF::RETURN_OK) {
     return result;
   }
-  return SerializeAdapter::serialize(&dataLen, buffer, size, maxSize, streamEndianness);
+  return SerializeAdapter::serialize(&params.dataLen, buffer, size, maxSize, streamEndianness);
 }
 
 size_t SpacePacketCreator::getSerializedSize() const { return 6; }
@@ -55,22 +43,25 @@ ReturnValue_t SpacePacketCreator::serialize(uint8_t **buffer, size_t *size, size
 }
 void SpacePacketCreator::setApid(uint16_t apid) {
   if (apid < ccsds::LIMIT_APID) {
-    packetId.apid = apid;
+    params.packetId.apid = apid;
   }
   checkFieldValidity();
 }
 
 void SpacePacketCreator::setSeqCount(uint16_t seqCount) {
   if (seqCount < ccsds::LIMIT_SEQUENCE_COUNT) {
-    packetSeqCtrl.seqCount = seqCount;
+    params.packetSeqCtrl.seqCount = seqCount;
   }
   checkFieldValidity();
 }
-void SpacePacketCreator::setSeqFlags(ccsds::SequenceFlags flags) { packetSeqCtrl.seqFlags = flags; }
-void SpacePacketCreator::setDataLen(uint16_t dataLen_) { dataLen = dataLen_; }
+void SpacePacketCreator::setSeqFlags(ccsds::SequenceFlags flags) {
+  params.packetSeqCtrl.seqFlags = flags;
+}
+void SpacePacketCreator::setDataLen(uint16_t dataLen_) { params.dataLen = dataLen_; }
 void SpacePacketCreator::checkFieldValidity() {
   valid = true;
-  if (packetId.apid > ccsds::LIMIT_APID or packetSeqCtrl.seqCount > ccsds::LIMIT_SEQUENCE_COUNT) {
+  if (params.packetId.apid > ccsds::LIMIT_APID or
+      params.packetSeqCtrl.seqCount > ccsds::LIMIT_SEQUENCE_COUNT) {
     valid = false;
   }
 }

src/fsfw/tmtcpacket/SpacePacketCreator.h

@@ -45,12 +45,21 @@ struct PacketSeqCtrl {
   uint16_t seqCount;
 };
 
-class SpacePacketCreator : public SerializeIF, public SpacePacketIF {
+struct SpacePacketParams {
+  PacketId packetId;
+  PacketSeqCtrl packetSeqCtrl;
+  uint16_t dataLen;
+  uint8_t version = 0b000;
+};
+
+class SpacePacketCreator : public SpacePacketIF, public SerializeIF {
  public:
+  /*
   SpacePacketCreator(ccsds::PacketType packetType, bool secHeaderFlag, uint16_t apid,
                      ccsds::SequenceFlags seqFlags, uint16_t seqCount, uint16_t dataLen,
                      uint8_t version = 0);
-  SpacePacketCreator(PacketId packetId, PacketSeqCtrl psc, uint16_t dataLen, uint8_t version = 0);
+  */
+  explicit SpacePacketCreator(SpacePacketParams &params);
   [[nodiscard]] bool isValid() const;
   [[nodiscard]] uint16_t getPacketId() const override;
   [[nodiscard]] uint16_t getPacketSeqCtrl() const override;
@@ -73,9 +82,6 @@ class SpacePacketCreator : public SerializeIF, public SpacePacketIF {
   void checkFieldValidity();
 
   bool valid{};
-  PacketId packetId;
-  PacketSeqCtrl packetSeqCtrl;
-  uint16_t dataLen;
-  uint8_t version;
+  SpacePacketParams params;
 };
 #endif  // FSFW_TMTCPACKET_SPACEPACKETCREATOR_H

src/fsfw/tmtcpacket/SpacePacketIF.h

@@ -1,6 +1,7 @@
 #ifndef FSFW_TMTCPACKET_SPACEPACKETIF_H
 #define FSFW_TMTCPACKET_SPACEPACKETIF_H
 
+#include <cstddef>
 #include <cstdint>
 
 #include "ccsds_header.h"
@@ -72,6 +73,10 @@ class SpacePacketIF {
     return ((packetId >> 8) & 0b111) | (packetId & 0xFF);
   }
 
+  /**
+   * Returns the CCSDS version number
+   * @return
+   */
   [[nodiscard]] virtual uint8_t getVersion() const {
     uint16_t packetId = getPacketId();
     return (packetId >> 13) & 0b111;
@@ -97,6 +102,14 @@ class SpacePacketIF {
   }
 
   [[nodiscard]] virtual uint16_t getSequenceCount() const { return getPacketSeqCtrl() & 0x3FFF; }
+
+  /**
+   * Returns the full packet length based of the packet data length field
+   * @return
+   */
+  [[nodiscard]] virtual size_t getFullPacketLen() const {
+    return sizeof(CCSDSPrimaryHeader) + getPacketDataLen() + 1;
+  }
 };
 
 #endif  // FSFW_TMTCPACKET_SPACEPACKETIF_H

src/fsfw/tmtcpacket/SpacePacketReader.cpp

@@ -2,39 +2,44 @@
 
 #include <cstring>
 
+#include "fsfw/serialize/SerializeIF.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-SpacePacketReader::SpacePacketReader(const uint8_t* setAddress) {
-  this->data = reinterpret_cast<SpacePacketPointer*>(const_cast<uint8_t*>(setAddress));
+SpacePacketReader::SpacePacketReader(const uint8_t* setAddress, size_t maxSize_) {
+  setInternalFields(setAddress, maxSize_);
+}
+
+ReturnValue_t SpacePacketReader::checkLength() const {
+  if (getFullPacketLen() > maxSize) {
+    return SerializeIF::STREAM_TOO_SHORT;
+  }
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
 SpacePacketReader::~SpacePacketReader() = default;
 
 inline uint16_t SpacePacketReader::getPacketId() const {
-  return ((this->data->header.packetIdHAndVersion) << 8) + this->data->header.packetIdL;
+  return ((spHeader->packetIdHAndVersion) << 8) + spHeader->packetIdL;
 }
 
-size_t SpacePacketReader::getFullSize() {
-  // +1 is done because size in packet data length field is: size of data field -1
-  return this->getPacketDataLen() + sizeof(this->data->header) + 1;
+const uint8_t* SpacePacketReader::getPacketData() { return packetDataField; }
+
+ReturnValue_t SpacePacketReader::setData(uint8_t* pData, size_t maxSize_, void* args) {
+  setInternalFields(pData, maxSize_);
 }
 
-uint8_t* SpacePacketReader::getWholeData() { return reinterpret_cast<uint8_t*>(this->data); }
-
-uint8_t* SpacePacketReader::getPacketData() { return &(data->packet_data); }
-
-ReturnValue_t SpacePacketReader::setData(uint8_t* pData, size_t maxSize, void* args) {
-  if (maxSize < 6) {
-    return HasReturnvaluesIF::RETURN_FAILED;
-  }
-  this->data = reinterpret_cast<SpacePacketPointer*>(const_cast<uint8_t*>(pData));
-  return HasReturnvaluesIF::RETURN_OK;
-}
 uint16_t SpacePacketReader::getPacketSeqCtrl() const {
-  return ((this->data->header.packetSeqCtrlH & 0b00111111) << 8) +
-         this->data->header.packetSeqCtrlL;
+  return (spHeader->packetSeqCtrlH << 8) + spHeader->packetSeqCtrlL;
 }
 
 uint16_t SpacePacketReader::getPacketDataLen() const {
-  return ((this->data->header.packetLenH) << 8) + this->data->header.packetLenL;
+  return (spHeader->packetLenH << 8) | spHeader->packetIdL;
 }
+void SpacePacketReader::setInternalFields(const uint8_t* data, size_t maxSize_) {
+  maxSize = maxSize_;
+  spHeader = reinterpret_cast<const CCSDSPrimaryHeader*>(data);
+  packetDataField = data + sizeof(CCSDSPrimaryHeader);
+}
+const uint8_t* SpacePacketReader::getFullData() {
+  return reinterpret_cast<const uint8_t*>(spHeader);
+};

src/fsfw/tmtcpacket/SpacePacketReader.h

@@ -5,7 +5,7 @@
 
 #include <cstddef>
 
-#include "SpacePacketIF.h"
+#include "ReadablePacketIF.h"
 #include "ccsds_header.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
@@ -30,22 +30,17 @@
  * the most significant bit (from left).
  * @ingroup tmtcpackets
  */
-class SpacePacketReader : public SpacePacketIF, public RedirectableDataPointerIF {
- protected:
-  /**
-   * A pointer to a structure which defines the data structure of
-   * the packet header.
-   * To be hardware-safe, all elements are of byte size.
-   */
-  SpacePacketPointer* data;
-
+class SpacePacketReader : public SpacePacketIF,
+                          public ReadablePacketIF,
+                          public RedirectableDataPointerIF {
  public:
+  SpacePacketReader() = default;
   /**
    * This is the default constructor.
    * It sets its internal data pointer to the address passed.
    * @param set_address	The position where the packet data lies.
    */
-  explicit SpacePacketReader(const uint8_t* set_address);
+  explicit SpacePacketReader(const uint8_t* setAddress, size_t maxSize);
   /**
    * No data is allocated, so the destructor is empty.
    */
@@ -55,14 +50,12 @@ class SpacePacketReader : public SpacePacketIF, public RedirectableDataPointerIF
   [[nodiscard]] uint16_t getPacketSeqCtrl() const override;
   [[nodiscard]] uint16_t getPacketDataLen() const override;
 
-  // Helper methods:
-  /**
-   * This method returns a raw uint8_t pointer to the packet.
-   * @return	A \c uint8_t pointer to the first byte of the CCSDS primary header.
-   */
-  virtual uint8_t* getWholeData();
+  const uint8_t* getFullData() override;
 
-  uint8_t* getPacketData();
+  // Helper methods:
+  [[nodiscard]] ReturnValue_t checkLength() const;
+
+  const uint8_t* getPacketData();
 
   /**
    * With this method, the packet data pointer can be redirected to another
@@ -70,11 +63,18 @@ class SpacePacketReader : public SpacePacketIF, public RedirectableDataPointerIF
    * @param p_Data A pointer to another raw Space Packet.
    */
   ReturnValue_t setData(uint8_t* p_Data, size_t maxSize, void* args) override;
+
+ protected:
   /**
-   * This method returns the full raw packet size.
-   * @return	The full size of the packet in bytes.
+   * A pointer to a structure which defines the data structure of
+   * the packet header.
+   * To be hardware-safe, all elements are of byte size.
    */
-  size_t getFullSize();
+  const CCSDSPrimaryHeader* spHeader{};
+  const uint8_t* packetDataField{};
+  size_t maxSize = 0;
+
+  void setInternalFields(const uint8_t* data, size_t maxSize);
 };
 
 #endif /* FSFW_TMTCPACKET_SPACEPACKETBASE_H_ */

src/fsfw/tmtcpacket/cfdp/CFDPPacket.cpp

@@ -1,4 +1,4 @@
-#include "fsfw/tmtcpacket/cfdp/CFDPPacket.h"
+#include "fsfw/tmtcpacket/cfdp/CfdpPacket.h"
 
 #include <cstring>
 
@@ -6,15 +6,16 @@
 #include "fsfw/globalfunctions/arrayprinter.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-CFDPPacket::CFDPPacket(const uint8_t* setData) : SpacePacketReader(setData) {}
+CfdpReader::CfdpReader(const uint8_t* setData, size_t maxSize)
+    : SpacePacketReader(setData, maxSize) {}
 
-CFDPPacket::~CFDPPacket() {}
+CfdpReader::~CfdpReader() = default;
 
-void CFDPPacket::print() {
+void CfdpReader::print() {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
   sif::info << "CFDPPacket::print:" << std::endl;
 #else
   sif::printInfo("CFDPPacket::print:\n");
 #endif
-  arrayprinter::print(getWholeData(), getFullSize());
+  // arrayprinter::print(getWholeData(), getFullSize());
 }

src/fsfw/tmtcpacket/cfdp/CFDPPacketStored.cpp

@@ -1,14 +1,14 @@
-#include "fsfw/tmtcpacket/cfdp/CFDPPacketStored.h"
+#include "fsfw/tmtcpacket/cfdp/CfdpPacketStored.h"
 
 #include "fsfw/objectmanager/ObjectManager.h"
 
-CFDPPacketStored::CFDPPacketStored() : CFDPPacket(nullptr) {}
+CfdpPacketStored::CfdpPacketStored() : CfdpReader(nullptr) {}
 
-CFDPPacketStored::CFDPPacketStored(store_address_t setAddress) : CFDPPacket(nullptr) {
+CfdpPacketStored::CfdpPacketStored(store_address_t setAddress) : CfdpReader(nullptr) {
   this->setStoreAddress(setAddress);
 }
 
-CFDPPacketStored::CFDPPacketStored(const uint8_t* data, size_t size) : CFDPPacket(data) {
+CfdpPacketStored::CfdpPacketStored(const uint8_t* data, size_t size) : CfdpReader(data) {
   if (this->getFullSize() != size) {
     return;
   }
@@ -24,7 +24,7 @@ CFDPPacketStored::CFDPPacketStored(const uint8_t* data, size_t size) : CFDPPacke
   }
 }
 
-ReturnValue_t CFDPPacketStored::deletePacket() {
+ReturnValue_t CfdpPacketStored::deletePacket() {
   ReturnValue_t result = STORE->deleteData(this->storeAddress);
   this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
   // To circumvent size checks
@@ -35,7 +35,7 @@ ReturnValue_t CFDPPacketStored::deletePacket() {
 // CFDPPacket* CFDPPacketStored::getPacketBase() {
 //     return this;
 // }
-void CFDPPacketStored::setStoreAddress(store_address_t setAddress) {
+void CfdpPacketStored::setStoreAddress(store_address_t setAddress) {
   this->storeAddress = setAddress;
   const uint8_t* tempData = nullptr;
   size_t tempSize;
@@ -52,11 +52,11 @@ void CFDPPacketStored::setStoreAddress(store_address_t setAddress) {
   }
 }
 
-store_address_t CFDPPacketStored::getStoreAddress() { return this->storeAddress; }
+store_address_t CfdpPacketStored::getStoreAddress() { return this->storeAddress; }
 
-CFDPPacketStored::~CFDPPacketStored() = default;
+CfdpPacketStored::~CfdpPacketStored() = default;
 
-ReturnValue_t CFDPPacketStored::getData(const uint8_t** dataPtr, size_t* dataSize) {
+ReturnValue_t CfdpPacketStored::getData(const uint8_t** dataPtr, size_t* dataSize) {
   return HasReturnvaluesIF::RETURN_OK;
 }
 
@@ -64,7 +64,7 @@ ReturnValue_t CFDPPacketStored::getData(const uint8_t** dataPtr, size_t* dataSiz
 //     return HasReturnvaluesIF::RETURN_OK;
 // }
 
-bool CFDPPacketStored::checkAndSetStore() {
+bool CfdpPacketStored::checkAndSetStore() {
   if (STORE == nullptr) {
     STORE = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
     if (STORE == nullptr) {
@@ -77,7 +77,7 @@ bool CFDPPacketStored::checkAndSetStore() {
   return true;
 }
 
-bool CFDPPacketStored::isSizeCorrect() {
+bool CfdpPacketStored::isSizeCorrect() {
   const uint8_t* temp_data = nullptr;
   size_t temp_size;
   ReturnValue_t status = STORE->getData(this->storeAddress, &temp_data, &temp_size);

src/fsfw/tmtcpacket/cfdp/CMakeLists.txt

@@ -1 +1 @@
-target_sources(${LIB_FSFW_NAME} PRIVATE CFDPPacket.cpp CFDPPacketStored.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE)

src/fsfw/tmtcpacket/cfdp/CfdpPacket.h

@@ -3,7 +3,7 @@
 
 #include "fsfw/tmtcpacket/SpacePacketReader.h"
 
-class CFDPPacket : public SpacePacketReader {
+class CfdpReader : public SpacePacketReader {
  public:
   /**
    * This is the default constructor.
@@ -11,11 +11,11 @@ class CFDPPacket : public SpacePacketReader {
    * forwards the data pointer to the parent SpacePacketBase class.
    * @param setData	The position where the packet data lies.
    */
-  CFDPPacket(const uint8_t* setData);
+  explicit CfdpReader(const uint8_t* setData, size_t maxSize);
   /**
    * This is the empty default destructor.
    */
-  virtual ~CFDPPacket();
+  ~CfdpReader() override;
 
   /**
    * This is a debugging helper method that prints the whole packet content

src/fsfw/tmtcpacket/cfdp/CfdpPacketStored.h

@@ -1,25 +1,25 @@
-#ifndef FSFW_INC_FSFW_TMTCPACKET_CFDP_CFDPPACKETSTORED_H_
-#define FSFW_INC_FSFW_TMTCPACKET_CFDP_CFDPPACKETSTORED_H_
+#ifndef FSFW_TMTCPACKET_CFDP_CFDPPACKETSTORED_H_
+#define FSFW_TMTCPACKET_CFDP_CFDPPACKETSTORED_H_
 
 #include "../pus/tc/TcPacketStoredBase.h"
-#include "CFDPPacket.h"
+#include "CfdpPacket.h"
 
-class CFDPPacketStored : public CFDPPacket, public TcPacketStoredBase {
+class CfdpPacketStored : public CfdpReader {
  public:
   /**
    * Create stored packet with existing data.
    * @param data
    * @param size
    */
-  CFDPPacketStored(const uint8_t* data, size_t size);
+  CfdpPacketStored(const uint8_t* data, size_t size);
   /**
    * Create stored packet from existing packet in store
    * @param setAddress
    */
-  CFDPPacketStored(store_address_t setAddress);
-  CFDPPacketStored();
+  explicit CfdpPacketStored(store_address_t setAddress);
+  CfdpPacketStored();
 
-  virtual ~CFDPPacketStored();
+  ~CfdpPacketStored() override;
 
   /**
    * Getter function for the raw data.
@@ -53,4 +53,4 @@ class CFDPPacketStored : public CFDPPacket, public TcPacketStoredBase {
   bool checkAndSetStore();
 };
 
-#endif /* FSFW_INC_FSFW_TMTCPACKET_CFDP_CFDPPACKETSTORED_H_ */
+#endif /* FSFW_TMTCPACKET_CFDP_CFDPPACKETSTORED_H_ */

src/fsfw/tmtcpacket/packetmatcher/ApidMatcher.h

@@ -1,18 +1,19 @@
 #ifndef FSFW_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
 #define FSFW_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
 
-#include "../../globalfunctions/matching/SerializeableMatcherIF.h"
-#include "../../serialize/SerializeAdapter.h"
-#include "../../tmtcpacket/pus/tm/TmPacketMinimal.h"
+#include "fsfw/globalfunctions/matching/SerializeableMatcherIF.h"
+#include "fsfw/serialize/SerializeAdapter.h"
+#include "fsfw/tmtcpacket/pus/tm/PusTmIF.h"
+#include "fsfw/tmtcpacket/pus/tm/PusTmMinimal.h"
 
-class ApidMatcher : public SerializeableMatcherIF<TmPacketMinimal*> {
+class ApidMatcher : public SerializeableMatcherIF<PusTmIF*> {
  private:
   uint16_t apid;
 
  public:
   explicit ApidMatcher(uint16_t setApid) : apid(setApid) {}
-  explicit ApidMatcher(TmPacketMinimal* test) : apid(test->getApid()) {}
-  bool match(TmPacketMinimal* packet) override {
+  explicit ApidMatcher(PusTmIF* test) : apid(test->getApid()) {}
+  bool match(PusTmIF* packet) override {
     if (packet->getApid() == apid) {
       return true;
     } else {

src/fsfw/tmtcpacket/packetmatcher/PacketMatchTree.cpp

@@ -1,5 +1,6 @@
 #include "fsfw/tmtcpacket/packetmatcher/PacketMatchTree.h"
 
+#include "fsfw/storagemanager/LocalPool.h"
 #include "fsfw/tmtcpacket/packetmatcher/ApidMatcher.h"
 #include "fsfw/tmtcpacket/packetmatcher/ServiceMatcher.h"
 #include "fsfw/tmtcpacket/packetmatcher/SubserviceMatcher.h"
@@ -12,33 +13,34 @@ const LocalPool::LocalPoolConfig PacketMatchTree::poolConfig = {
     {40, sizeof(PacketMatchTree::Node)}};
 
 PacketMatchTree::PacketMatchTree(Node* root)
-    : MatchTree<TmPacketMinimal*>(root, 2),
+    : MatchTree<PusTmIF*>(root, 2),
       factoryBackend(0, poolConfig, false, true),
       factory(&factoryBackend) {}
 
 PacketMatchTree::PacketMatchTree(iterator root)
-    : MatchTree<TmPacketMinimal*>(root.element, 2),
+    : MatchTree<PusTmIF*>(root.element, 2),
       factoryBackend(0, poolConfig, false, true),
       factory(&factoryBackend) {}
 
 PacketMatchTree::PacketMatchTree()
-    : MatchTree<TmPacketMinimal*>((Node*)NULL, 2),
+    : MatchTree<PusTmIF*>(nullptr, 2),
       factoryBackend(0, poolConfig, false, true),
       factory(&factoryBackend) {}
 
-PacketMatchTree::~PacketMatchTree() {}
+PacketMatchTree::~PacketMatchTree() = default;
 
 ReturnValue_t PacketMatchTree::addMatch(uint16_t apid, uint8_t type, uint8_t subtype) {
   // We assume adding APID is always requested.
-  TmPacketMinimal::TmPacketMinimalPointer data;
-  data.data_field.service_type = type;
-  data.data_field.service_subtype = subtype;
-  TmPacketMinimal testPacket((uint8_t*)&data);
+  PusTmMinimal::TmPacketMinimalPointer data{};
+  data.secHeader.service_type = type;
+  data.secHeader.service_subtype = subtype;
+  PusTmMinimal testPacket((uint8_t*)&data);
   testPacket.setApid(apid);
+
   iterator lastTest;
   iterator rollback;
   ReturnValue_t result =
-      findOrInsertMatch<TmPacketMinimal*, ApidMatcher>(this->begin(), &testPacket, &lastTest);
+      findOrInsertMatch<PusTmIF*, ApidMatcher>(this->begin(), &testPacket, &lastTest);
   if (result == NEW_NODE_CREATED) {
     rollback = lastTest;
   } else if (result != RETURN_OK) {
@@ -47,38 +49,36 @@ ReturnValue_t PacketMatchTree::addMatch(uint16_t apid, uint8_t type, uint8_t sub
   if (type == 0) {
     // Check if lastTest has no children, otherwise, delete them,
     // as a more general check is requested.
-    if (lastTest.left() != this->end()) {
+    if (lastTest.left() != PacketMatchTree::end()) {
       removeElementAndAllChildren(lastTest.left());
     }
     return RETURN_OK;
   }
   // Type insertion required.
-  result =
-      findOrInsertMatch<TmPacketMinimal*, ServiceMatcher>(lastTest.left(), &testPacket, &lastTest);
+  result = findOrInsertMatch<PusTmIF*, ServiceMatcher>(lastTest.left(), &testPacket, &lastTest);
   if (result == NEW_NODE_CREATED) {
-    if (rollback == this->end()) {
+    if (rollback == PacketMatchTree::end()) {
       rollback = lastTest;
     }
   } else if (result != RETURN_OK) {
-    if (rollback != this->end()) {
+    if (rollback != PacketMatchTree::end()) {
       removeElementAndAllChildren(rollback);
     }
     return result;
   }
   if (subtype == 0) {
-    if (lastTest.left() != this->end()) {
+    if (lastTest.left() != PacketMatchTree::end()) {
       // See above
       removeElementAndAllChildren(lastTest.left());
     }
     return RETURN_OK;
   }
   // Subtype insertion required.
-  result = findOrInsertMatch<TmPacketMinimal*, SubServiceMatcher>(lastTest.left(), &testPacket,
-                                                                  &lastTest);
+  result = findOrInsertMatch<PusTmIF*, SubServiceMatcher>(lastTest.left(), &testPacket, &lastTest);
   if (result == NEW_NODE_CREATED) {
     return RETURN_OK;
   } else if (result != RETURN_OK) {
-    if (rollback != this->end()) {
+    if (rollback != PacketMatchTree::end()) {
       removeElementAndAllChildren(rollback);
     }
     return result;
@@ -91,7 +91,7 @@ ReturnValue_t PacketMatchTree::findOrInsertMatch(iterator startAt, VALUE_T test,
                                                  iterator* lastTest) {
   bool attachToBranch = AND;
   iterator iter = startAt;
-  while (iter != this->end()) {
+  while (iter != PacketMatchTree::end()) {
     bool isMatch = iter->match(test);
     attachToBranch = OR;
     *lastTest = iter;
@@ -104,11 +104,11 @@ ReturnValue_t PacketMatchTree::findOrInsertMatch(iterator startAt, VALUE_T test,
   }
   // Only reached if nothing was found.
   SerializeableMatcherIF<VALUE_T>* newContent = factory.generate<INSERTION_T>(test);
-  if (newContent == NULL) {
+  if (newContent == nullptr) {
     return FULL;
   }
   Node* newNode = factory.generate<Node>(newContent);
-  if (newNode == NULL) {
+  if (newNode == nullptr) {
     // Need to make sure partially generated content is deleted, otherwise, that's a leak.
     factory.destroy<INSERTION_T>(static_cast<INSERTION_T*>(newContent));
     return FULL;
@@ -122,10 +122,10 @@ ReturnValue_t PacketMatchTree::findOrInsertMatch(iterator startAt, VALUE_T test,
 }
 
 ReturnValue_t PacketMatchTree::removeMatch(uint16_t apid, uint8_t type, uint8_t subtype) {
-  TmPacketMinimal::TmPacketMinimalPointer data;
-  data.data_field.service_type = type;
-  data.data_field.service_subtype = subtype;
-  TmPacketMinimal testPacket((uint8_t*)&data);
+  PusTmMinimal::TmPacketMinimalPointer data;
+  data.secHeader.service_type = type;
+  data.secHeader.service_subtype = subtype;
+  PusTmMinimal testPacket((uint8_t*)&data);
   testPacket.setApid(apid);
   iterator foundElement = findMatch(begin(), &testPacket);
   if (foundElement == this->end()) {
@@ -158,7 +158,7 @@ ReturnValue_t PacketMatchTree::removeMatch(uint16_t apid, uint8_t type, uint8_t
   return removeElementAndReconnectChildren(foundElement);
 }
 
-PacketMatchTree::iterator PacketMatchTree::findMatch(iterator startAt, TmPacketMinimal* test) {
+PacketMatchTree::iterator PacketMatchTree::findMatch(iterator startAt, PusTmIF* test) {
   iterator iter = startAt;
   while (iter != end()) {
     bool isMatch = iter->match(test);

src/fsfw/tmtcpacket/packetmatcher/PacketMatchTree.h

@@ -4,21 +4,22 @@
 #include "fsfw/container/PlacementFactory.h"
 #include "fsfw/globalfunctions/matching/MatchTree.h"
 #include "fsfw/storagemanager/LocalPool.h"
-#include "fsfw/tmtcpacket/pus/tm/TmPacketMinimal.h"
+#include "fsfw/tmtcpacket/pus/tm/PusTmIF.h"
+#include "fsfw/tmtcpacket/pus/tm/PusTmMinimal.h"
 
-class PacketMatchTree : public MatchTree<TmPacketMinimal*>, public HasReturnvaluesIF {
+class PacketMatchTree : public MatchTree<PusTmIF*>, public HasReturnvaluesIF {
  public:
-  PacketMatchTree(Node* root);
-  PacketMatchTree(iterator root);
+  explicit PacketMatchTree(Node* root);
+  explicit PacketMatchTree(iterator root);
   PacketMatchTree();
-  virtual ~PacketMatchTree();
+  ~PacketMatchTree() override;
   ReturnValue_t changeMatch(bool addToMatch, uint16_t apid, uint8_t type = 0, uint8_t subtype = 0);
   ReturnValue_t addMatch(uint16_t apid, uint8_t type = 0, uint8_t subtype = 0);
   ReturnValue_t removeMatch(uint16_t apid, uint8_t type = 0, uint8_t subtype = 0);
   ReturnValue_t initialize();
 
  protected:
-  ReturnValue_t cleanUpElement(iterator position);
+  ReturnValue_t cleanUpElement(iterator position) override;
 
  private:
   static const uint8_t N_POOLS = 4;
@@ -29,7 +30,7 @@ class PacketMatchTree : public MatchTree<TmPacketMinimal*>, public HasReturnvalu
   static const uint16_t N_ELEMENTS[N_POOLS];
   template <typename VALUE_T, typename INSERTION_T>
   ReturnValue_t findOrInsertMatch(iterator startAt, VALUE_T test, iterator* lastTest);
-  iterator findMatch(iterator startAt, TmPacketMinimal* test);
+  iterator findMatch(iterator startAt, PusTmIF* test);
 };
 
-#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_ */
+#endif /* FSFW_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_ */

src/fsfw/tmtcpacket/packetmatcher/ServiceMatcher.h

@@ -3,16 +3,16 @@
 
 #include "../../globalfunctions/matching/SerializeableMatcherIF.h"
 #include "../../serialize/SerializeAdapter.h"
-#include "../pus/tm/TmPacketMinimal.h"
+#include "../pus/tm/PusTmMinimal.h"
 
-class ServiceMatcher : public SerializeableMatcherIF<TmPacketMinimal*> {
+class ServiceMatcher : public SerializeableMatcherIF<PusTmIF*> {
  private:
   uint8_t service;
 
  public:
-  ServiceMatcher(uint8_t setService) : service(setService) {}
-  ServiceMatcher(TmPacketMinimal* test) : service(test->getService()) {}
-  bool match(TmPacketMinimal* packet) {
+  explicit ServiceMatcher(uint8_t setService) : service(setService) {}
+  explicit ServiceMatcher(PusTmIF* test) : service(test->getService()) {}
+  bool match(PusTmIF* packet) override {
     if (packet->getService() == service) {
       return true;
     } else {
@@ -20,11 +20,14 @@ class ServiceMatcher : public SerializeableMatcherIF<TmPacketMinimal*> {
     }
   }
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          Endianness streamEndianness) const {
+                          Endianness streamEndianness) const override {
     return SerializeAdapter::serialize(&service, buffer, size, maxSize, streamEndianness);
   }
-  size_t getSerializedSize() const { return SerializeAdapter::getSerializedSize(&service); }
-  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
+  [[nodiscard]] size_t getSerializedSize() const override {
+    return SerializeAdapter::getSerializedSize(&service);
+  }
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            Endianness streamEndianness) override {
     return SerializeAdapter::deSerialize(&service, buffer, size, streamEndianness);
   }
 };

src/fsfw/tmtcpacket/packetmatcher/SubserviceMatcher.h

@@ -3,13 +3,13 @@
 
 #include "../../globalfunctions/matching/SerializeableMatcherIF.h"
 #include "../../serialize/SerializeAdapter.h"
-#include "../pus/tm/TmPacketMinimal.h"
+#include "../pus/tm/PusTmMinimal.h"
 
-class SubServiceMatcher : public SerializeableMatcherIF<TmPacketMinimal*> {
+class SubServiceMatcher : public SerializeableMatcherIF<PusTmIF*> {
  public:
-  SubServiceMatcher(uint8_t subService) : subService(subService) {}
-  SubServiceMatcher(TmPacketMinimal* test) : subService(test->getSubService()) {}
-  bool match(TmPacketMinimal* packet) {
+  explicit SubServiceMatcher(uint8_t subService) : subService(subService) {}
+  explicit SubServiceMatcher(PusTmIF* test) : subService(test->getSubService()) {}
+  bool match(PusTmIF* packet) override {
     if (packet->getSubService() == subService) {
       return true;
     } else {
@@ -17,16 +17,19 @@ class SubServiceMatcher : public SerializeableMatcherIF<TmPacketMinimal*> {
     }
   }
   ReturnValue_t serialize(uint8_t** buffer, size_t* size, size_t maxSize,
-                          Endianness streamEndianness) const {
+                          Endianness streamEndianness) const override {
     return SerializeAdapter::serialize(&subService, buffer, size, maxSize, streamEndianness);
   }
-  size_t getSerializedSize() const { return SerializeAdapter::getSerializedSize(&subService); }
-  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size, Endianness streamEndianness) {
+  [[nodiscard]] size_t getSerializedSize() const override {
+    return SerializeAdapter::getSerializedSize(&subService);
+  }
+  ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
+                            Endianness streamEndianness) override {
     return SerializeAdapter::deSerialize(&subService, buffer, size, streamEndianness);
   }
 
  private:
-  uint8_t subService;
+  uint8_t subService{};
 };
 
 #endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_ */

src/fsfw/tmtcpacket/pus/PacketTimestampInterpreterIF.h

@@ -3,13 +3,13 @@
 
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 
-class TmPacketMinimal;
+class PusTmMinimal;
 
 class PacketTimestampInterpreterIF {
  public:
   virtual ~PacketTimestampInterpreterIF() {}
-  virtual ReturnValue_t getPacketTime(TmPacketMinimal* packet, timeval* timestamp) const = 0;
-  virtual ReturnValue_t getPacketTimeRaw(TmPacketMinimal* packet, const uint8_t** timePtr,
+  virtual ReturnValue_t getPacketTime(PusTmMinimal* packet, timeval* timestamp) const = 0;
+  virtual ReturnValue_t getPacketTimeRaw(PusTmMinimal* packet, const uint8_t** timePtr,
                                          uint32_t* size) const = 0;
 };
 

src/fsfw/tmtcpacket/pus/PusIF.h

@@ -0,0 +1,52 @@
+#ifndef FSFW_TMTCPACKET_PUSIF_H
+#define FSFW_TMTCPACKET_PUSIF_H
+
+#include <cstdint>
+
+#include "fsfw/tmtcpacket/SpacePacketIF.h"
+
+class PusIF : public SpacePacketIF {
+ public:
+  ~PusIF() override = default;
+  /**
+   * This command returns the TC Packet PUS Version Number.
+   * The version number of ECSS PUS 2003 is 1.
+   * It consists of the second to fourth highest bits of the
+   * first byte.
+   * @return
+   */
+  [[nodiscard]] virtual uint8_t getPusVersion() const = 0;
+
+  /**
+   * This is a getter for the packet's PUS Service ID, which is the second
+   * byte of the Data Field Header.
+   * @return	The packet's PUS Service ID.
+   */
+  [[nodiscard]] virtual uint8_t getService() const = 0;
+  /**
+   * This is a getter for the packet's PUS Service Subtype, which is the
+   * third byte of the Data Field Header.
+   * @return	The packet's PUS Service Subtype.
+   */
+  [[nodiscard]] virtual uint8_t getSubService() const = 0;
+
+  /**
+   * This is a getter for a pointer to the packet's Application data.
+   *
+   * These are the bytes that follow after the Data Field Header. They form
+   * the packet's application data.
+   * @return	A pointer to the PUS Application Data.
+   */
+  [[nodiscard]] virtual const uint8_t* getUserData(size_t& appDataLen) const = 0;
+  /**
+   * This method calculates the size of the PUS Application data field.
+   *
+   * It takes the information stored in the CCSDS Packet Data Length field
+   * and subtracts the Data Field Header size and the CRC size.
+   * @return	The size of the PUS Application Data (without Error Control
+   * 		field)
+   */
+  [[nodiscard]] virtual uint16_t getUserDataSize() const = 0;
+};
+
+#endif  // FSFW_TMTCPACKET_PUSIF_H

src/fsfw/tmtcpacket/pus/definitions.h

@@ -3,11 +3,11 @@
 
 #include <cstdint>
 
-namespace pus {
+namespace ecss {
 
 //! Version numbers according to ECSS-E-ST-70-41C p.439
-enum PusVersion : uint8_t { PUS_A_VERSION = 1, PUS_C_VERSION = 2 };
+enum PusVersion : uint8_t { PUS_A = 1, PUS_C = 2 };
 
-}  // namespace pus
+}  // namespace ecss
 
 #endif /* FSFW_SRC_FSFW_TMTCPACKET_PUS_TM_DEFINITIONS_H_ */

src/fsfw/tmtcpacket/pus/tc.h

@@ -2,6 +2,5 @@
 #define FSFW_TMTCPACKET_PUS_TC_H_
 
 #include "tc/TcPacketPus.h"
-#include "tc/TcPacketStoredPus.h"
 
 #endif /* FSFW_TMTCPACKET_PUS_TC_H_ */

src/fsfw/tmtcpacket/pus/tc/CMakeLists.txt

@@ -1,4 +1,4 @@
-target_sources(
-  ${LIB_FSFW_NAME}
-  PRIVATE PusTcReader.cpp TcPacketPus.cpp PusTcReader.cpp PusTcCreator.cpp
-          TcPacketStoredBase.cpp TcPacketStoredPus.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE PusTcReader.cpp PusTcReader.cpp
+                                        PusTcCreator.cpp)
+
+# TcPacketPus.cpp

src/fsfw/tmtcpacket/pus/tc/PusTcCreator.cpp

@@ -1,3 +1,75 @@
 #include "PusTcCreator.h"
 
-TcPacketDeserializer::TcPacketDeserializer(const uint8_t *data, size_t maxSize) {}
+#include "PusTcIF.h"
+#include "fsfw/globalfunctions/CRC.h"
+#include "fsfw/serialize/SerializeAdapter.h"
+
+PusTcCreator::PusTcCreator(SpacePacketParams spParams, PusTcParams pusParams)
+    : spCreator(spParams), pusParams(pusParams) {
+  updateSpLengthField();
+}
+
+ReturnValue_t PusTcCreator::serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                                      SerializeIF::Endianness streamEndianness) const {
+  if (*size + PusTcIF::MIN_LEN + pusParams.appDataLen > maxSize) {
+    return SerializeIF::BUFFER_TOO_SHORT;
+  }
+  ReturnValue_t result = spCreator.serialize(buffer, size, maxSize, streamEndianness);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  if (pusParams.pusVersion != ecss::PusVersion::PUS_C) {
+    // TODO: Dedicated returnvalue
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  **buffer = pusParams.pusVersion << 4 | pusParams.ackFlags;
+  *buffer += 1;
+  **buffer = pusParams.service;
+  *buffer += 1;
+  **buffer = pusParams.subservice;
+  *buffer += 1;
+  result =
+      SerializeAdapter::serialize(&pusParams.sourceId, buffer, size, maxSize, streamEndianness);
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
+  }
+  std::memcpy(*buffer, pusParams.appData, pusParams.appDataLen);
+  *buffer += pusParams.appDataLen;
+  *size += pusParams.appDataLen;
+  uint16_t crc16 = CRC::crc16ccitt(*buffer, getFullPacketLen() - 2);
+  return SerializeAdapter::serialize(&crc16, buffer, size, maxSize, streamEndianness);
+}
+
+void PusTcCreator::updateSpLengthField() {
+  spCreator.setDataLen(ecss::PusTcDataFieldHeader::MIN_LEN + pusParams.appDataLen + 1);
+}
+
+size_t PusTcCreator::getSerializedSize() const { return spCreator.getFullPacketLen(); }
+
+ReturnValue_t PusTcCreator::deSerialize(const uint8_t **buffer, size_t *size,
+                                        SerializeIF::Endianness streamEndianness) {
+  return HasReturnvaluesIF::RETURN_FAILED;
+}
+
+uint16_t PusTcCreator::getPacketId() const { return spCreator.getPacketId(); }
+
+uint16_t PusTcCreator::getPacketSeqCtrl() const { return spCreator.getPacketSeqCtrl(); }
+
+uint16_t PusTcCreator::getPacketDataLen() const { return spCreator.getPacketDataLen(); }
+
+uint8_t PusTcCreator::getPusVersion() const { return pusParams.pusVersion; }
+
+uint8_t PusTcCreator::getAcknowledgeFlags() const { return pusParams.ackFlags; }
+
+uint8_t PusTcCreator::getService() const { return pusParams.service; }
+
+uint8_t PusTcCreator::getSubService() const { return pusParams.subservice; }
+
+uint16_t PusTcCreator::getSourceId() const { return pusParams.sourceId; }
+
+const uint8_t *PusTcCreator::getUserData(size_t &appDataLen) const {
+  appDataLen = getUserDataSize();
+  return pusParams.appData;
+}
+
+uint16_t PusTcCreator::getUserDataSize() const { return pusParams.appDataLen; }

src/fsfw/tmtcpacket/pus/tc/PusTcCreator.h

@@ -2,13 +2,47 @@
 #define FSFW_TMTCPACKET_TCPACKETDESERIALIZER_H
 
 #include "fsfw/tmtcpacket/RedirectableDataPointerIF.h"
+#include "fsfw/tmtcpacket/SpacePacketCreator.h"
 #include "fsfw/tmtcpacket/SpacePacketIF.h"
+#include "fsfw/tmtcpacket/pus/definitions.h"
+#include "fsfw/tmtcpacket/pus/tc/PusTcIF.h"
 
-class PusTcCreator : public SpacePacketIF {
+struct PusTcParams {
+  PusTcParams(uint8_t service_, uint8_t subservice_) : service(service_), subservice(subservice_) {}
+
+  uint8_t service;
+  uint8_t subservice;
+  uint8_t ackFlags = ecss::ACK_ALL;
+  uint16_t sourceId = 0;
+  uint8_t *appData = nullptr;
+  size_t appDataLen = 0;
+  uint8_t pusVersion = ecss::PusVersion::PUS_C;
+};
+
+class PusTcCreator : public PusTcIF, public SerializeIF {
  public:
-  PusTcCreator(const uint8_t* data, size_t maxSize);
+  PusTcCreator(SpacePacketParams spParams, PusTcParams pusParams);
+
+  void updateSpLengthField();
+  ReturnValue_t serialize(uint8_t **buffer, size_t *size, size_t maxSize,
+                          Endianness streamEndianness) const override;
+  [[nodiscard]] size_t getSerializedSize() const override;
+  ReturnValue_t deSerialize(const uint8_t **buffer, size_t *size,
+                            Endianness streamEndianness) override;
+  [[nodiscard]] uint16_t getPacketId() const override;
+  [[nodiscard]] uint16_t getPacketSeqCtrl() const override;
+  [[nodiscard]] uint16_t getPacketDataLen() const override;
+  [[nodiscard]] uint8_t getPusVersion() const override;
+  [[nodiscard]] uint8_t getAcknowledgeFlags() const override;
+  [[nodiscard]] uint8_t getService() const override;
+  [[nodiscard]] uint8_t getSubService() const override;
+  [[nodiscard]] uint16_t getSourceId() const override;
+  const uint8_t *getUserData(size_t &appDataLen) const override;
+  [[nodiscard]] uint16_t getUserDataSize() const override;
 
  private:
+  SpacePacketCreator spCreator;
+  PusTcParams pusParams;
 };
 
 #endif  // FSFW_TMTCPACKET_TCPACKETDESERIALIZER_H

src/fsfw/tmtcpacket/pus/tc/PusTcIF.h

@@ -3,7 +3,7 @@
 
 #include <cstdint>
 
-#include "TcPacketPus.h"
+#include "fsfw/tmtcpacket/pus/PusIF.h"
 
 namespace ecss {
 
@@ -41,20 +41,12 @@ struct PusTcDataFieldHeader {
 
 }  // namespace ecss
 
-class PusTcIF : public SpacePacketIF {
+class PusTcIF : public PusIF {
  public:
   ~PusTcIF() override = default;
-  static const uint16_t MIN_LEN =
+  static const size_t MIN_LEN =
       (sizeof(CCSDSPrimaryHeader) + ecss::PusTcDataFieldHeader::MIN_LEN + 2);
 
-  /**
-   * This command returns the TC Packet PUS Version Number.
-   * The version number of ECSS PUS 2003 is 1.
-   * It consists of the second to fourth highest bits of the
-   * first byte.
-   * @return
-   */
-  [[nodiscard]] virtual uint8_t getPusVersion() const = 0;
   /**
    * This is a getter for the packet's Ack field, which are the lowest four
    * bits of the first byte of the Data Field Header.
@@ -63,50 +55,13 @@ class PusTcIF : public SpacePacketIF {
    * @return	The packet's PUS Ack field.
    */
   [[nodiscard]] virtual uint8_t getAcknowledgeFlags() const = 0;
-  /**
-   * This is a getter for the packet's PUS Service ID, which is the second
-   * byte of the Data Field Header.
-   * @return	The packet's PUS Service ID.
-   */
-  [[nodiscard]] virtual uint8_t getService() const = 0;
-  /**
-   * This is a getter for the packet's PUS Service Subtype, which is the
-   * third byte of the Data Field Header.
-   * @return	The packet's PUS Service Subtype.
-   */
-  [[nodiscard]] virtual uint8_t getSubService() const = 0;
+
   /**
    * The source ID can be used to have an additional identifier, e.g. for different ground
    * station.
    * @return
    */
   [[nodiscard]] virtual uint16_t getSourceId() const = 0;
-
-  /**
-   * This is a getter for a pointer to the packet's Application data.
-   *
-   * These are the bytes that follow after the Data Field Header. They form
-   * the packet's application data.
-   * @return	A pointer to the PUS Application Data.
-   */
-  [[nodiscard]] virtual const uint8_t* getApplicationData() const = 0;
-  /**
-   * This method calculates the size of the PUS Application data field.
-   *
-   * It takes the information stored in the CCSDS Packet Data Length field
-   * and subtracts the Data Field Header size and the CRC size.
-   * @return	The size of the PUS Application Data (without Error Control
-   * 		field)
-   */
-  [[nodiscard]] virtual uint16_t getApplicationDataSize() const = 0;
-  /**
-   * This getter returns the Error Control Field of the packet.
-   *
-   * The field is placed after any possible Application Data. If no
-   * Application Data is present there's still an Error Control field. It is
-   * supposed to be a 16bit-CRC.
-   * @return	The PUS Error Control
-   */
-  [[nodiscard]] virtual uint16_t getErrorControl() const = 0;
 };
+
 #endif  // FSFW_TMTCPACKET_PUSTCIF_H

src/fsfw/tmtcpacket/pus/tc/PusTcReader.cpp

@@ -7,33 +7,64 @@
 #include "fsfw/serialize.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-PusTcReader::PusTcReader(const uint8_t* setData, size_t size) : spReader(setData), maxSize(size) {
-  pointers.spHeaderStart = setData;
-}
+PusTcReader::PusTcReader(const uint8_t* data, size_t size) { setData(data, size); }
 
 PusTcReader::~PusTcReader() = default;
 
 ReturnValue_t PusTcReader::parseData() {
-  if (maxSize < sizeof(CCSDSPrimaryHeader)) {
-    return SerializeIF::BUFFER_TOO_SHORT;
+  ReturnValue_t result = spReader.checkLength();
+  if (result != HasReturnvaluesIF::RETURN_OK) {
+    return result;
   }
+  if (size < PusTcIF::MIN_LEN) {
+    return SerializeIF::STREAM_TOO_SHORT;
+  }
+  // Might become variable sized field in the future
+  size_t secHeaderLen = ecss::PusTcDataFieldHeader::MIN_LEN;
   pointers.secHeaderStart = pointers.spHeaderStart + sizeof(CCSDSPrimaryHeader);
   // TODO: No support for spare bytes yet
-  pointers.userDataStart = pointers.secHeaderStart + ecss::PusTcDataFieldHeader::MIN_LEN;
+  pointers.userDataStart = pointers.secHeaderStart + secHeaderLen;
+  appDataSize = size - (sizeof(CCSDSPrimaryHeader) + secHeaderLen);
+  pointers.crcStart = pointers.userDataStart + appDataSize;
+  return HasReturnvaluesIF::RETURN_OK;
 }
 
-uint8_t PusTcReader::getAcknowledgeFlags() const { return 0; }
-uint8_t PusTcReader::getService() const { return 0; }
-uint8_t PusTcReader::getSubService() const { return 0; }
-uint16_t PusTcReader::getSourceId() const { return 0; }
-const uint8_t* PusTcReader::getApplicationData() const { return nullptr; }
-uint16_t PusTcReader::getApplicationDataSize() const { return 0; }
-uint16_t PusTcReader::getErrorControl() const { return 0; }
+uint8_t PusTcReader::getAcknowledgeFlags() const {
+  return (pointers.secHeaderStart[0] >> 4) & 0b1111;
+}
+
+uint8_t PusTcReader::getService() const { return pointers.secHeaderStart[1]; }
+
+uint8_t PusTcReader::getSubService() const { return pointers.secHeaderStart[2]; }
+uint16_t PusTcReader::getSourceId() const {
+  return (pointers.secHeaderStart[3] << 8) | pointers.secHeaderStart[4];
+}
+const uint8_t* PusTcReader::getUserData(size_t& appDataLen) const {
+  appDataLen = appDataSize;
+  return pointers.userDataStart;
+}
+
+uint16_t PusTcReader::getUserDataSize() const { return appDataSize; }
+
+uint16_t PusTcReader::getErrorControl() const {
+  return pointers.crcStart[0] << 8 | pointers.crcStart[1];
+}
 
 uint16_t PusTcReader::getPacketId() const { return spReader.getPacketId(); }
 uint16_t PusTcReader::getPacketSeqCtrl() const { return spReader.getPacketSeqCtrl(); }
 uint16_t PusTcReader::getPacketDataLen() const { return spReader.getPacketDataLen(); }
 uint8_t PusTcReader::getPusVersion() const { return spReader.getVersion(); }
+const uint8_t* PusTcReader::getFullData() { return pointers.spHeaderStart; }
+
+ReturnValue_t PusTcReader::setData(uint8_t* pData, size_t size_, void* args) {
+  size = size_;
+  pointers.spHeaderStart = pData;
+  spReader.setData(pData, size_, args);
+  return HasReturnvaluesIF::RETURN_OK;
+}
+ReturnValue_t PusTcReader::setData(const uint8_t* data, size_t size_) {
+  setData(const_cast<uint8_t*>(data), size_, nullptr);
+}
 
 /*
 void PusTcReader::print() {

src/fsfw/tmtcpacket/pus/tc/PusTcReader.h

@@ -18,17 +18,16 @@
  * check can be performed by making use of the getWholeData method.
  * @ingroup tmtcpackets
  */
-class PusTcReader : public PusTcIF, public RedirectableDataPointerIF {
-  friend class TcPacketStoredBase;
-
+class PusTcReader : public PusTcIF, public ReadablePacketIF, public RedirectableDataPointerIF {
  public:
+  PusTcReader() = default;
   /**
    * This is the default constructor.
    * It sets its internal data pointer to the address passed and also
    * forwards the data pointer to the parent SpacePacketBase class.
    * @param setData	The position where the packet data lies.
    */
-  explicit PusTcReader(const uint8_t* setData, size_t size);
+  PusTcReader(const uint8_t* setData, size_t size);
 
   ReturnValue_t parseData();
   /**
@@ -40,7 +39,7 @@ class PusTcReader : public PusTcIF, public RedirectableDataPointerIF {
    * This is a debugging helper method that prints the whole packet content
    * to the screen.
    */
-  void print();
+  // void print();
   [[nodiscard]] uint16_t getPacketId() const override;
   [[nodiscard]] uint16_t getPacketSeqCtrl() const override;
   [[nodiscard]] uint16_t getPacketDataLen() const override;
@@ -49,9 +48,12 @@ class PusTcReader : public PusTcIF, public RedirectableDataPointerIF {
   [[nodiscard]] uint8_t getService() const override;
   [[nodiscard]] uint8_t getSubService() const override;
   [[nodiscard]] uint16_t getSourceId() const override;
-  [[nodiscard]] const uint8_t* getApplicationData() const override;
-  [[nodiscard]] uint16_t getApplicationDataSize() const override;
-  [[nodiscard]] uint16_t getErrorControl() const override;
+  [[nodiscard]] const uint8_t* getUserData(size_t& appDataLen) const override;
+  [[nodiscard]] uint16_t getUserDataSize() const override;
+  [[nodiscard]] uint16_t getErrorControl() const;
+  const uint8_t* getFullData() override;
+
+  ReturnValue_t setData(const uint8_t* data, size_t size);
 
  protected:
   /**
@@ -62,7 +64,8 @@ class PusTcReader : public PusTcIF, public RedirectableDataPointerIF {
    *
    * @param p_data    A pointer to another PUS Telecommand Packet.
    */
-  ReturnValue_t setData(uint8_t* pData, size_t maxSize, void* args) override = 0;
+  ReturnValue_t setData(uint8_t* pData, size_t size, void* args) override;
+
   SpacePacketReader spReader;
   /**
    * This struct defines the data structure of a Space Packet when accessed
@@ -73,10 +76,12 @@ class PusTcReader : public PusTcIF, public RedirectableDataPointerIF {
     const uint8_t* spHeaderStart;
     const uint8_t* secHeaderStart;
     const uint8_t* userDataStart;
+    const uint8_t* crcStart;
   };
 
   PusTcPointers pointers{};
-  size_t maxSize = 0;
+  size_t size = 0;
+  size_t appDataSize = 0;
 };
 
 #endif /* TMTCPACKET_PUS_TCPACKETBASE_H_ */

src/fsfw/tmtcpacket/pus/tc/TcPacketPus.cpp

@@ -10,7 +10,7 @@ TcPacketPus::TcPacketPus(const uint8_t *setData) : TcPacketPusBase(setData) {
 
 void TcPacketPus::initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack,
                                      uint8_t service, uint8_t subservice,
-                                     pus::PusVersion pusVersion, uint16_t sourceId) {
+                                     ecss::PusVersion pusVersion, uint16_t sourceId) {
   initSpacePacketHeader(true, true, apid, sequenceCount);
   std::memset(&tcData->dataField, 0, sizeof(tcData->dataField));
   setPacketDataLength(sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);

src/fsfw/tmtcpacket/pus/tc/TcPacketPus.h

@@ -21,49 +21,49 @@ struct TcPacketPointer {
 };
  */
 
-class TcPacketPus : public TcPacketPusBase {
- public:
-  /**
-   * Initialize a PUS A telecommand packet which already exists. You can also
-   * create an empty (invalid) object by passing nullptr as the data pointer
-   * @param setData
-   */
-  TcPacketPus(const uint8_t* setData);
-
-  // Base class overrides
-  uint8_t getSecondaryHeaderFlag() const override;
-  uint8_t getPusVersionNumber() const override;
-  uint8_t getAcknowledgeFlags() const override;
-  uint8_t getService() const override;
-  uint8_t getSubService() const override;
-  uint16_t getSourceId() const override;
-  const uint8_t* getApplicationData() const override;
-  uint16_t getApplicationDataSize() const override;
-  uint16_t getErrorControl() const override;
-  void setErrorControl() override;
-  size_t calculateFullPacketLength(size_t appDataLen) const override;
-
- protected:
-  ReturnValue_t setData(uint8_t* dataPtr, size_t maxSize, void* args) override;
-
-  /**
-   * Initializes the Tc Packet header.
-   * @param apid APID used.
-   * @param sequenceCount Sequence Count in the primary header.
-   * @param ack Which acknowledeges are expected from the receiver.
-   * @param service   PUS Service
-   * @param subservice PUS Subservice
-   */
-  void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack, uint8_t service,
-                          uint8_t subservice, pus::PusVersion pusVersion, uint16_t sourceId = 0);
-
-  /**
-   * A pointer to a structure which defines the data structure of
-   * the packet's data.
-   *
-   * To be hardware-safe, all elements are of byte size.
-   */
-  TcPacketPointer* tcData = nullptr;
-};
+// class TcPacketPus : public TcPacketPusBase {
+//  public:
+//   /**
+//    * Initialize a PUS A telecommand packet which already exists. You can also
+//    * create an empty (invalid) object by passing nullptr as the data pointer
+//    * @param setData
+//    */
+//   TcPacketPus(const uint8_t* setData);
+//
+//   // Base class overrides
+//   uint8_t getSecondaryHeaderFlag() const override;
+//   uint8_t getPusVersionNumber() const override;
+//   uint8_t getAcknowledgeFlags() const override;
+//   uint8_t getService() const override;
+//   uint8_t getSubService() const override;
+//   uint16_t getSourceId() const override;
+//   const uint8_t* getApplicationData() const override;
+//   uint16_t getApplicationDataSize() const override;
+//   uint16_t getErrorControl() const override;
+//   void setErrorControl() override;
+//   size_t calculateFullPacketLength(size_t appDataLen) const override;
+//
+//  protected:
+//   ReturnValue_t setData(uint8_t* dataPtr, size_t maxSize, void* args) override;
+//
+//   /**
+//    * Initializes the Tc Packet header.
+//    * @param apid APID used.
+//    * @param sequenceCount Sequence Count in the primary header.
+//    * @param ack Which acknowledeges are expected from the receiver.
+//    * @param service   PUS Service
+//    * @param subservice PUS Subservice
+//    */
+//   void initializeTcPacket(uint16_t apid, uint16_t sequenceCount, uint8_t ack, uint8_t service,
+//                           uint8_t subservice, pus::PusVersion pusVersion, uint16_t sourceId = 0);
+//
+//   /**
+//    * A pointer to a structure which defines the data structure of
+//    * the packet's data.
+//    *
+//    * To be hardware-safe, all elements are of byte size.
+//    */
+//   TcPacketPointer* tcData = nullptr;
+// };
 
 #endif /* FSFW_TMTCPACKET_PUS_TCPACKETPUSA_H_ */

src/fsfw/tmtcpacket/pus/tc/TcPacketStored.cpp

@@ -0,0 +1 @@
+#include "TcPacketStored.h"

src/fsfw/tmtcpacket/pus/tc/TcPacketStored.h

@@ -0,0 +1,10 @@
+#ifndef FSFW_TMTCPACKET_TCPACKETSTORED_H
+#define FSFW_TMTCPACKET_TCPACKETSTORED_H
+
+#include "fsfw/tmtcpacket/PacketStorageHelper.h"
+
+class TcPacketStored : public PacketStorageHelper {
+  TcPacketStored(StorageManagerIF* store);
+};
+
+#endif  // FSFW_TMTCPACKET_TCPACKETSTORED_H

src/fsfw/tmtcpacket/pus/tc/TcPacketStoredBase.cpp

@@ -6,58 +6,59 @@
 #include "fsfw/objectmanager/frameworkObjects.h"
 #include "fsfw/serviceinterface/ServiceInterface.h"
 
-StorageManagerIF* TcPacketStoredBase::STORE = nullptr;
-
-TcPacketStoredBase::TcPacketStoredBase() {
-  this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-  TcPacketStoredBase::checkAndSetStore();
-}
-
-TcPacketStoredBase::~TcPacketStoredBase() = default;
-
-ReturnValue_t TcPacketStoredBase::getData(const uint8_t** dataPtr, size_t* dataSize) {
-  auto result = TcPacketStoredBase::STORE->getData(storeAddress, dataPtr, dataSize);
-  if (result != HasReturnvaluesIF::RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "TcPacketStoredBase: Could not get data" << std::endl;
-#else
-    sif::printWarning("TcPacketStoredBase: Could not get data!\n");
-#endif
-  }
-  return result;
-}
-
-bool TcPacketStoredBase::checkAndSetStore() {
-  if (TcPacketStoredBase::STORE == nullptr) {
-    TcPacketStoredBase::STORE = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
-    if (TcPacketStoredBase::STORE == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-      sif::error << "TcPacketStoredBase::TcPacketStoredBase: TC Store not found" << std::endl;
-#else
-      sif::printError("TcPacketStoredBase::TcPacketStoredBase: TC Store not found\n");
-#endif
-      return false;
-    }
-  }
-  return true;
-}
-
-void TcPacketStoredBase::setStoreAddress(store_address_t setAddress,
-                                         RedirectableDataPointerIF* packet) {
-  this->storeAddress = setAddress;
-  const uint8_t* tempData = nullptr;
-  size_t tempSize;
-  ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
-  if (this->checkAndSetStore()) {
-    status = TcPacketStoredBase::STORE->getData(this->storeAddress, &tempData, &tempSize);
-  }
-
-  if (status == StorageManagerIF::RETURN_OK) {
-    packet->setData(const_cast<uint8_t*>(tempData), tempSize);
-  } else {
-    packet->setData(nullptr, -1);
-    this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-  }
-}
-
-store_address_t TcPacketStoredBase::getStoreAddress() { return this->storeAddress; }
+// StorageManagerIF* TcPacketStoredBase::STORE = nullptr;
+//
+// TcPacketStoredBase::TcPacketStoredBase() {
+//   this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+//   TcPacketStoredBase::checkAndSetStore();
+// }
+//
+// TcPacketStoredBase::~TcPacketStoredBase() = default;
+//
+// ReturnValue_t TcPacketStoredBase::getData(const uint8_t** dataPtr, size_t* dataSize) {
+//   auto result = TcPacketStoredBase::STORE->getData(storeAddress, dataPtr, dataSize);
+//   if (result != HasReturnvaluesIF::RETURN_OK) {
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//     sif::warning << "TcPacketStoredBase: Could not get data" << std::endl;
+//#else
+//     sif::printWarning("TcPacketStoredBase: Could not get data!\n");
+//#endif
+//   }
+//   return result;
+// }
+//
+// bool TcPacketStoredBase::checkAndSetStore() {
+//   if (TcPacketStoredBase::STORE == nullptr) {
+//     TcPacketStoredBase::STORE =
+//     ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE); if
+//     (TcPacketStoredBase::STORE == nullptr) {
+//#if FSFW_CPP_OSTREAM_ENABLED == 1
+//       sif::error << "TcPacketStoredBase::TcPacketStoredBase: TC Store not found" << std::endl;
+//#else
+//       sif::printError("TcPacketStoredBase::TcPacketStoredBase: TC Store not found\n");
+//#endif
+//       return false;
+//     }
+//   }
+//   return true;
+// }
+//
+// void TcPacketStoredBase::setStoreAddress(store_address_t setAddress,
+//                                          RedirectableDataPointerIF* packet) {
+//   this->storeAddress = setAddress;
+//   const uint8_t* tempData = nullptr;
+//   size_t tempSize;
+//   ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
+//   if (this->checkAndSetStore()) {
+//     status = TcPacketStoredBase::STORE->getData(this->storeAddress, &tempData, &tempSize);
+//   }
+//
+//   if (status == StorageManagerIF::RETURN_OK) {
+//     packet->setData(const_cast<uint8_t*>(tempData), tempSize);
+//   } else {
+//     packet->setData(nullptr, -1);
+//     this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+//   }
+// }
+//
+// store_address_t TcPacketStoredBase::getStoreAddress() { return this->storeAddress; }

src/fsfw/tmtcpacket/pus/tc/TcPacketStoredBase.h

@@ -5,80 +5,80 @@
 #include "TcPacketStoredIF.h"
 #include "fsfw/storagemanager/StorageManagerIF.h"
 
-/**
- *	Base class for telecommand packets like CFDP or PUS packets.
- *	@ingroup tmtcpackets
- */
-class TcPacketStoredBase : public TcPacketStoredIF {
- public:
-  /**
-   * This is a default constructor which does not set the data pointer to initialize
-   * with an empty cached store address
-   */
-  TcPacketStoredBase();
-  /**
-   * Constructor to set to an existing store address.
-   * @param setAddress
-   */
-  explicit TcPacketStoredBase(store_address_t setAddress);
-  /**
-   * Another constructor to create a TcPacket from a raw packet stream.
-   * Takes the data and adds it unchecked to the TcStore.
-   * @param data  Pointer to the complete TC Space Packet.
-   * @param Size size of the packet.
-   */
-  TcPacketStoredBase(const uint8_t* data, uint32_t size);
-
-  virtual ~TcPacketStoredBase();
-
-  /**
-   * Getter function for the raw data.
-   * @param dataPtr [out] Pointer to the data pointer to set
-   * @param dataSize [out] Address of size to set.
-   * @return -@c RETURN_OK if data was retrieved successfully.
-   */
-  ReturnValue_t getData(const uint8_t** dataPtr, size_t* dataSize) override;
-
-  void setStoreAddress(store_address_t setAddress, RedirectableDataPointerIF* packet) override;
-  store_address_t getStoreAddress() override;
-
-  /**
-   * With this call, the packet is deleted.
-   * It removes itself from the store and sets its data pointer to NULL.
-   * @return	returncode from deleting the data.
-   */
-  virtual ReturnValue_t deletePacket() = 0;
-
-  /**
-   * This method performs a size check.
-   * It reads the stored size and compares it with the size entered in the
-   * packet header. This class is the optimal place for such a check as it
-   * has access to both the header data and the store.
-   * @return	true if size is correct, false if packet is not registered in
-   * 			store or size is incorrect.
-   */
-  virtual bool isSizeCorrect() = 0;
-
- protected:
-  /**
-   * This is a pointer to the store all instances of the class use.
-   * If the store is not yet set (i.e. @c store is NULL), every constructor
-   * call tries to set it and throws an error message in case of failures.
-   * The default store is objects::TC_STORE.
-   */
-  static StorageManagerIF* STORE;
-  /**
-   * The address where the packet data of the object instance is stored.
-   */
-  store_address_t storeAddress;
-  /**
-   * A helper method to check if a store is assigned to the class.
-   * If not, the method tries to retrieve the store from the global
-   * ObjectManager.
-   * @return  @li @c true if the store is linked or could be created.
-   *          @li @c false otherwise.
-   */
-  static bool checkAndSetStore();
-};
+///**
+// *	Base class for telecommand packets like CFDP or PUS packets.
+// *	@ingroup tmtcpackets
+// */
+// class TcPacketStoredBase : public TcPacketStoredIF {
+// public:
+//  /**
+//   * This is a default constructor which does not set the data pointer to initialize
+//   * with an empty cached store address
+//   */
+//  TcPacketStoredBase();
+//  /**
+//   * Constructor to set to an existing store address.
+//   * @param setAddress
+//   */
+//  explicit TcPacketStoredBase(store_address_t setAddress);
+//  /**
+//   * Another constructor to create a TcPacket from a raw packet stream.
+//   * Takes the data and adds it unchecked to the TcStore.
+//   * @param data  Pointer to the complete TC Space Packet.
+//   * @param Size size of the packet.
+//   */
+//  TcPacketStoredBase(const uint8_t* data, uint32_t size);
+//
+//  virtual ~TcPacketStoredBase();
+//
+//  /**
+//   * Getter function for the raw data.
+//   * @param dataPtr [out] Pointer to the data pointer to set
+//   * @param dataSize [out] Address of size to set.
+//   * @return -@c RETURN_OK if data was retrieved successfully.
+//   */
+//  ReturnValue_t getData(const uint8_t** dataPtr, size_t* dataSize) override;
+//
+//  void setStoreAddress(store_address_t setAddress, RedirectableDataPointerIF* packet) override;
+//  store_address_t getStoreAddress() override;
+//
+//  /**
+//   * With this call, the packet is deleted.
+//   * It removes itself from the store and sets its data pointer to NULL.
+//   * @return	returncode from deleting the data.
+//   */
+//  virtual ReturnValue_t deletePacket() = 0;
+//
+//  /**
+//   * This method performs a size check.
+//   * It reads the stored size and compares it with the size entered in the
+//   * packet header. This class is the optimal place for such a check as it
+//   * has access to both the header data and the store.
+//   * @return	true if size is correct, false if packet is not registered in
+//   * 			store or size is incorrect.
+//   */
+//  virtual bool isSizeCorrect() = 0;
+//
+// protected:
+//  /**
+//   * This is a pointer to the store all instances of the class use.
+//   * If the store is not yet set (i.e. @c store is NULL), every constructor
+//   * call tries to set it and throws an error message in case of failures.
+//   * The default store is objects::TC_STORE.
+//   */
+//  static StorageManagerIF* STORE;
+//  /**
+//   * The address where the packet data of the object instance is stored.
+//   */
+//  store_address_t storeAddress;
+//  /**
+//   * A helper method to check if a store is assigned to the class.
+//   * If not, the method tries to retrieve the store from the global
+//   * ObjectManager.
+//   * @return  @li @c true if the store is linked or could be created.
+//   *          @li @c false otherwise.
+//   */
+//  static bool checkAndSetStore();
+//};
 
 #endif /* TMTCPACKET_PUS_TCPACKETSTORED_H_ */

src/fsfw/tmtcpacket/pus/tc/TcPacketStoredPus.cpp

@@ -1,78 +0,0 @@
-#include "fsfw/tmtcpacket/pus/tc/TcPacketStoredPus.h"
-
-#include <cstring>
-
-#include "fsfw/serviceinterface/ServiceInterface.h"
-
-TcPacketStoredPus::TcPacketStoredPus(uint16_t apid, uint8_t service, uint8_t subservice,
-                                     uint8_t sequenceCount, const uint8_t* data, size_t size,
-                                     uint8_t ack)
-    : TcPacketPus(nullptr) {
-  this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-  if (not this->checkAndSetStore()) {
-    return;
-  }
-  uint8_t* pData = nullptr;
-  ReturnValue_t returnValue =
-      this->STORE->getFreeElement(&this->storeAddress, (TC_PACKET_MIN_SIZE + size), &pData);
-  if (returnValue != this->STORE->RETURN_OK) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::warning << "TcPacketStoredBase: Could not get free element from store!" << std::endl;
-#endif
-    return;
-  }
-  this->setData(pData, TC_PACKET_MIN_SIZE + size, nullptr);
-#if FSFW_USE_PUS_C_TELECOMMANDS == 1
-  pus::PusVersion pusVersion = pus::PusVersion::PUS_C_VERSION;
-#else
-  pus::PusVersion pusVersion = pus::PusVersion::PUS_A_VERSION;
-#endif
-  initializeTcPacket(apid, sequenceCount, ack, service, subservice, pusVersion);
-  std::memcpy(&tcData->appData, data, size);
-  this->setPacketDataLength(size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE - 1);
-  this->setErrorControl();
-}
-
-TcPacketStoredPus::TcPacketStoredPus() : TcPacketStoredBase(), TcPacketPus(nullptr) {}
-
-TcPacketStoredPus::TcPacketStoredPus(store_address_t setAddress) : TcPacketPus(nullptr) {
-  TcPacketStoredBase::setStoreAddress(setAddress, this);
-}
-
-TcPacketStoredPus::TcPacketStoredPus(const uint8_t* data, size_t size) : TcPacketPus(data) {
-  if (this->getFullSize() != size) {
-    return;
-  }
-  if (this->checkAndSetStore()) {
-    ReturnValue_t status = STORE->addData(&storeAddress, data, size);
-    if (status != HasReturnvaluesIF::RETURN_OK) {
-      this->setData(nullptr, size, nullptr);
-    }
-    const uint8_t* storePtr = nullptr;
-    // Repoint base data pointer to the data in the store.
-    STORE->getData(storeAddress, &storePtr, &size);
-    this->setData(const_cast<uint8_t*>(storePtr), size, nullptr);
-  }
-}
-
-ReturnValue_t TcPacketStoredPus::deletePacket() {
-  ReturnValue_t result = this->STORE->deleteData(this->storeAddress);
-  this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-  // To circumvent size checks
-  this->setData(nullptr, -1, nullptr);
-  return result;
-}
-
-TcPacketPusBase* TcPacketStoredPus::getPacketBase() { return this; }
-
-bool TcPacketStoredPus::isSizeCorrect() {
-  const uint8_t* temp_data = nullptr;
-  size_t temp_size;
-  ReturnValue_t status = this->STORE->getData(this->storeAddress, &temp_data, &temp_size);
-  if (status == StorageManagerIF::RETURN_OK) {
-    if (this->getFullSize() == temp_size) {
-      return true;
-    }
-  }
-  return false;
-}

src/fsfw/tmtcpacket/pus/tc/TcPacketStoredPus.h

@@ -1,48 +0,0 @@
-#ifndef FSFW_TMTCPACKET_PUS_TCPACKETSTOREDPUSA_H_
-#define FSFW_TMTCPACKET_PUS_TCPACKETSTOREDPUSA_H_
-
-#include "TcPacketPus.h"
-#include "TcPacketStoredBase.h"
-
-class TcPacketStoredPus : public TcPacketStoredBase, public TcPacketPus {
- public:
-  /**
-   * With this constructor, new space is allocated in the packet store and
-   * a new PUS Telecommand Packet is created there.
-   * Packet Application Data passed in data is copied into the packet.
-   * @param apid          Sets the packet's APID field.
-   * @param service       Sets the packet's Service ID field.
-   *                      This specifies the destination service.
-   * @param subservice    Sets the packet's Service Subtype field.
-   *                      This specifies the destination sub-service.
-   * @param sequence_count Sets the packet's Source Sequence Count field.
-   * @param data      The data to be copied to the Application Data Field.
-   * @param size      The amount of data to be copied.
-   * @param ack           Set's the packet's Ack field, which specifies
-   *                      number of verification packets returned
-   *                      for this command.
-   */
-  TcPacketStoredPus(uint16_t apid, uint8_t service, uint8_t subservice, uint8_t sequence_count = 0,
-                    const uint8_t* data = nullptr, size_t size = 0,
-                    uint8_t ack = TcPacketPusBase::ACK_ALL);
-  /**
-   * Create stored packet with existing data.
-   * @param data
-   * @param size
-   */
-  TcPacketStoredPus(const uint8_t* data, size_t size);
-  /**
-   * Create stored packet from existing packet in store
-   * @param setAddress
-   */
-  TcPacketStoredPus(store_address_t setAddress);
-  TcPacketStoredPus();
-
-  ReturnValue_t deletePacket() override;
-  TcPacketPusBase* getPacketBase();
-
- private:
-  bool isSizeCorrect() override;
-};
-
-#endif /* FSFW_TMTCPACKET_PUS_TCPACKETSTOREDPUSA_H_ */

src/fsfw/tmtcpacket/pus/tm.h

@@ -11,6 +11,6 @@
 #include "tm/TmPacketStoredPusA.h"
 #endif
 
-#include "tm/TmPacketMinimal.h"
+#include "tm/PusTmMinimal.h"
 
 #endif /* FSFW_TMTCPACKET_PUS_TM_H_ */

src/fsfw/tmtcpacket/pus/tm/CMakeLists.txt

@@ -1,4 +1,2 @@
-target_sources(
-  ${LIB_FSFW_NAME}
-  PRIVATE TmPacketStoredPusC.cpp TmPacketPusC.cpp TmPacketStoredBase.cpp
-          TmPacketBase.cpp TmPacketMinimal.cpp)
+target_sources(${LIB_FSFW_NAME} PRIVATE PusTmCreator.cpp PusTmReader.cpp
+                                        PusTmMinimal.cpp)

src/fsfw/tmtcpacket/pus/tm/PusTmCreator.cpp

@@ -0,0 +1,10 @@
+#include "PusTmCreator.h"
+
+PusTmCreator::PusTmCreator(PusTmParams params_) : params(params_){};
+
+uint16_t PusTmCreator::getPacketId() const { return 0; }
+uint16_t PusTmCreator::getPacketSeqCtrl() const { return 0; }
+uint16_t PusTmCreator::getPacketDataLen() const { return 0; }
+uint8_t PusTmCreator::getPusVersion() const { return 0; }
+uint8_t PusTmCreator::getService() const { return 0; }
+uint8_t PusTmCreator::getSubService() const { return 0; }

src/fsfw/tmtcpacket/pus/tm/PusTmCreator.h

@@ -0,0 +1,31 @@
+#ifndef FSFW_TMTCPACKET_TMPACKETCREATOR_H
+#define FSFW_TMTCPACKET_TMPACKETCREATOR_H
+
+#include "fsfw/tmtcpacket/pus/PusIF.h"
+
+struct PusTmParams {
+  uint8_t pusVersion;
+  uint8_t scTimeRefStatus;
+  uint8_t service;
+  uint8_t subservice;
+  uint16_t messageTypeCounter;
+  uint16_t destId;
+  uint8_t* timestamp;
+  size_t timestampLen;
+};
+class PusTmCreator : public PusIF {
+ public:
+  ~PusTmCreator() override = default;
+  explicit PusTmCreator(PusTmParams params);
+
+  [[nodiscard]] uint16_t getPacketId() const override;
+  [[nodiscard]] uint16_t getPacketSeqCtrl() const override;
+  [[nodiscard]] uint16_t getPacketDataLen() const override;
+  [[nodiscard]] uint8_t getPusVersion() const override;
+  [[nodiscard]] uint8_t getService() const override;
+  [[nodiscard]] uint8_t getSubService() const override;
+
+ private:
+  PusTmParams params;
+};
+#endif  // FSFW_TMTCPACKET_TMPACKETCREATOR_H

src/fsfw/tmtcpacket/pus/tm/PusTmIF.h

@@ -0,0 +1,20 @@
+#ifndef FSFW_TMTCPACKET_PUSTMIF_H
+#define FSFW_TMTCPACKET_PUSTMIF_H
+
+#include <cstddef>
+#include <cstdint>
+
+#include "fsfw/tmtcpacket/pus/PusIF.h"
+
+class PusTmIF : public PusIF {
+ public:
+  ~PusTmIF() override = default;
+
+  virtual uint8_t getScTimeRefStatus() = 0;
+  virtual uint16_t getMessageTypeCounter() = 0;
+  virtual uint16_t getDestId() = 0;
+  virtual const uint8_t* getTimestamp(size_t& timeStampLen) = 0;
+  virtual size_t getTimestampLen() = 0;
+};
+
+#endif  // FSFW_TMTCPACKET_PUSTMIF_H

src/fsfw/tmtcpacket/pus/tm/PusTmMinimal.cpp

@@ -0,0 +1,45 @@
+#include "fsfw/tmtcpacket/pus/tm/PusTmMinimal.h"
+
+#include <cstddef>
+#include <ctime>
+
+#include "fsfw/tmtcpacket/pus/PacketTimestampInterpreterIF.h"
+
+PusTmMinimal::PusTmMinimal(uint8_t* data) {
+  this->tmData = reinterpret_cast<TmPacketMinimalPointer*>(data);
+}
+
+PusTmMinimal::~PusTmMinimal() = default;
+
+ReturnValue_t PusTmMinimal::getPacketTime(timeval* timestamp) {
+  if (timestampInterpreter == nullptr) {
+    return HasReturnvaluesIF::RETURN_FAILED;
+  }
+  return timestampInterpreter->getPacketTime(this, timestamp);
+}
+
+void PusTmMinimal::setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter) {
+  if (PusTmMinimal::timestampInterpreter == nullptr) {
+    PusTmMinimal::timestampInterpreter = interpreter;
+  }
+}
+
+PacketTimestampInterpreterIF* PusTmMinimal::timestampInterpreter = nullptr;
+// TODO: Implement all of this
+ReturnValue_t PusTmMinimal::setData(uint8_t* dataPtr, size_t size, void* args) { return 0; }
+uint16_t PusTmMinimal::getPacketId() const { return 0; }
+uint16_t PusTmMinimal::getPacketSeqCtrl() const { return 0; }
+uint16_t PusTmMinimal::getPacketDataLen() const { return 0; }
+uint8_t PusTmMinimal::getPusVersion() const { return 0; }
+uint8_t PusTmMinimal::getService() const { return tmData->secHeader.service; }
+uint8_t PusTmMinimal::getSubService() const { return tmData->secHeader.subservice; }
+const uint8_t* PusTmMinimal::getUserData(size_t& appDataLen) const { return nullptr; }
+uint16_t PusTmMinimal::getUserDataSize() const { return 0; }
+uint8_t PusTmMinimal::getScTimeRefStatus() { return 0; }
+uint16_t PusTmMinimal::getMessageTypeCounter() { return tmData->secHeader.messageTypeCounter; }
+uint16_t PusTmMinimal::getDestId() { return 0; }
+const uint8_t* PusTmMinimal::getTimestamp(size_t& timeStampLen) { return nullptr; }
+size_t PusTmMinimal::getTimestampLen() { return 0; }
+void PusTmMinimal::setApid(uint16_t apid) {
+  /* TODO: Implement. Maybe provide low level function to do this */
+}

src/fsfw/tmtcpacket/pus/tm/PusTmMinimal.h

@@ -1,8 +1,9 @@
 #ifndef FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
 #define FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
 
-#include "../../../returnvalues/HasReturnvaluesIF.h"
-#include "../../SpacePacketReader.h"
+#include "PusTmIF.h"
+#include "fsfw/returnvalues/HasReturnvaluesIF.h"
+#include "fsfw/tmtcpacket/SpacePacketReader.h"
 
 struct timeval;
 class PacketTimestampInterpreterIF;
@@ -12,7 +13,7 @@ class PacketTimestampInterpreterIF;
  * This is required for handling TM packets with different APIDs with different
  * secondary headers.
  */
-class TmPacketMinimal : public SpacePacketReader {
+class PusTmMinimal : public PusTmIF, public RedirectableDataPointerIF {
  public:
   /**
    * This is the default constructor.
@@ -20,40 +21,40 @@ class TmPacketMinimal : public SpacePacketReader {
    * forwards the data pointer to the parent SpacePacketBase class.
    * @param set_address	The position where the packet data lies.
    */
-  TmPacketMinimal(const uint8_t* set_data);
+  explicit PusTmMinimal(uint8_t* data);
   /**
    * This is the empty default destructor.
    */
-  virtual ~TmPacketMinimal();
-  /**
-   * This is a getter for the packet's PUS Service ID, which is the second
-   * byte of the Data Field Header.
-   * @return	The packet's PUS Service ID.
-   */
-  uint8_t getService();
-  /**
-   * This is a getter for the packet's PUS Service Subtype, which is the
-   * third byte of the Data Field Header.
-   * @return	The packet's PUS Service Subtype.
-   */
-  uint8_t getSubService();
-  /**
-   * Returns the subcounter.
-   * @return the subcounter of the Data Field Header.
-   */
-  uint8_t getPacketSubcounter();
-  struct PUSTmMinimalHeader {
-    uint8_t version_type_ack;
-    uint8_t service_type;
-    uint8_t service_subtype;
-    uint8_t subcounter;
-  };
+  ~PusTmMinimal() override;
+
+  void setApid(uint16_t apid);
 
   ReturnValue_t getPacketTime(timeval* timestamp);
 
-  ReturnValue_t getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size);
-
   static void setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter);
+  ReturnValue_t setData(uint8_t* dataPtr, size_t size, void* args) override;
+  [[nodiscard]] uint16_t getPacketId() const override;
+  [[nodiscard]] uint16_t getPacketSeqCtrl() const override;
+  [[nodiscard]] uint16_t getPacketDataLen() const override;
+  [[nodiscard]] uint8_t getPusVersion() const override;
+  [[nodiscard]] uint8_t getService() const override;
+  [[nodiscard]] uint8_t getSubService() const override;
+  const uint8_t* getUserData(size_t& appDataLen) const override;
+  [[nodiscard]] uint16_t getUserDataSize() const override;
+  uint8_t getScTimeRefStatus() override;
+  uint16_t getMessageTypeCounter() override;
+  uint16_t getDestId() override;
+  const uint8_t* getTimestamp(size_t& timeStampLen) override;
+  size_t getTimestampLen() override;
+
+  // NOTE: Only PUS C compatible!
+  struct PusTmMinimalSecHeader {
+    uint8_t versionAndScTimeRefStatus;
+    uint8_t service;
+    uint8_t subservice;
+    uint16_t messageTypeCounter;
+  };
+
   /**
    * This struct defines the data structure of a PUS Telecommand Packet when
    * accessed via a pointer.
@@ -61,7 +62,7 @@ class TmPacketMinimal : public SpacePacketReader {
    */
   struct TmPacketMinimalPointer {
     CCSDSPrimaryHeader primary;
-    PUSTmMinimalHeader data_field;
+    PusTmMinimalSecHeader secHeader;
     uint8_t rest;
   };
   // Must include a checksum and is therefore at least one larger than the above struct.
@@ -74,7 +75,7 @@ class TmPacketMinimal : public SpacePacketReader {
    *
    * To be hardware-safe, all elements are of byte size.
    */
-  TmPacketMinimalPointer* tm_data;
+  TmPacketMinimalPointer* tmData;
 
   static PacketTimestampInterpreterIF* timestampInterpreter;
 };

src/fsfw/tmtcpacket/pus/tm/PusTmReader.cpp

@@ -0,0 +1,3 @@
+//
+// Created by rmueller on 7/19/22.
+//

src/fsfw/tmtcpacket/pus/tm/PusTmReader.h

@@ -0,0 +1,7 @@
+#ifndef FSFW_TMTCPACKET_PUSTMREADER_H
+#define FSFW_TMTCPACKET_PUSTMREADER_H
+
+#include "fsfw/tmtcpacket/pus/tm/PusTmIF.h"
+
+class PusTmReader : public PusTmIF {};
+#endif  // FSFW_TMTCPACKET_PUSTMREADER_H

src/fsfw/tmtcpacket/pus/tm/TmPacketMinimal.cpp

@@ -1,40 +0,0 @@
-#include "fsfw/tmtcpacket/pus/tm/TmPacketMinimal.h"
-
-#include <cstddef>
-#include <ctime>
-
-#include "fsfw/tmtcpacket/pus/PacketTimestampInterpreterIF.h"
-
-TmPacketMinimal::TmPacketMinimal(const uint8_t* set_data) : SpacePacketReader(set_data) {
-  this->tm_data = (TmPacketMinimalPointer*)set_data;
-}
-
-TmPacketMinimal::~TmPacketMinimal() {}
-
-uint8_t TmPacketMinimal::getService() { return tm_data->data_field.service_type; }
-
-uint8_t TmPacketMinimal::getSubService() { return tm_data->data_field.service_subtype; }
-
-uint8_t TmPacketMinimal::getPacketSubcounter() { return tm_data->data_field.subcounter; }
-
-ReturnValue_t TmPacketMinimal::getPacketTime(timeval* timestamp) {
-  if (timestampInterpreter == NULL) {
-    return HasReturnvaluesIF::RETURN_FAILED;
-  }
-  return timestampInterpreter->getPacketTime(this, timestamp);
-}
-
-ReturnValue_t TmPacketMinimal::getPacketTimeRaw(const uint8_t** timePtr, uint32_t* size) {
-  if (timestampInterpreter == NULL) {
-    return HasReturnvaluesIF::RETURN_FAILED;
-  }
-  return timestampInterpreter->getPacketTimeRaw(this, timePtr, size);
-}
-
-void TmPacketMinimal::setInterpretTimestampObject(PacketTimestampInterpreterIF* interpreter) {
-  if (TmPacketMinimal::timestampInterpreter == NULL) {
-    TmPacketMinimal::timestampInterpreter = interpreter;
-  }
-}
-
-PacketTimestampInterpreterIF* TmPacketMinimal::timestampInterpreter = NULL;

src/fsfw/tmtcpacket/pus/tm/TmPacketPusC.cpp

@@ -58,8 +58,7 @@ ReturnValue_t TmPacketPusC::initializeTmPacket(uint16_t apid, uint8_t service, u
 
   /* Only account for last 4 bytes for time reference field */
   timeRefField &= 0b1111;
-  tmData->dataField.versionTimeReferenceField =
-      (pus::PusVersion::PUS_C_VERSION << 4) | timeRefField;
+  tmData->dataField.versionTimeReferenceField = (ecss::PusVersion::PUS_C << 4) | timeRefField;
   tmData->dataField.serviceType = service;
   tmData->dataField.serviceSubtype = subservice;
   tmData->dataField.subcounterMsb = (packetSubcounter << 8) & 0xff;

src/fsfw/tmtcservices/PusServiceBase.cpp

@@ -11,8 +11,9 @@
 object_id_t PusServiceBase::packetSource = 0;
 object_id_t PusServiceBase::packetDestination = 0;
 
-PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid, uint8_t setServiceId)
-    : SystemObject(setObjectId), apid(setApid), serviceId(setServiceId) {
+PusServiceBase::PusServiceBase(object_id_t setObjectId, uint16_t setApid, uint8_t setServiceId,
+                               StorageManagerIF* store_)
+    : SystemObject(setObjectId), apid(setApid), serviceId(setServiceId), store(store_) {
   requestQueue = QueueFactory::instance()->createMessageQueue(PUS_SERVICE_MAX_RECEPTION);
 }
 
@@ -31,7 +32,7 @@ ReturnValue_t PusServiceBase::performOperation(uint8_t opCode) {
   return RETURN_OK;
 }
 
-void PusServiceBase::setTaskIF(PeriodicTaskIF* taskHandle) { this->taskHandle = taskHandle; }
+void PusServiceBase::setTaskIF(PeriodicTaskIF* taskHandle_) { this->taskHandle = taskHandle_; }
 
 void PusServiceBase::handleRequestQueue() {
   TmTcMessage message;
@@ -49,7 +50,14 @@ void PusServiceBase::handleRequestQueue() {
     //		}
 
     if (status == RETURN_OK) {
-      this->currentPacket.setStoreAddress(message.getStorageId(), &currentPacket);
+      const uint8_t* dataPtr;
+      size_t dataLen = 0;
+      result = store->getData(message.getStorageId(), &dataPtr, &dataLen);
+      if (result != HasReturnvaluesIF::RETURN_OK) {
+        // TODO: Warning?
+      }
+
+      currentPacket.setData(dataPtr, dataLen);
       // info << "Service " << (uint16_t) this->serviceId <<
       //      ": new packet!" << std::endl;
 
@@ -65,7 +73,7 @@ void PusServiceBase::handleRequestQueue() {
                                                &this->currentPacket, result, 0, errorParameter1,
                                                errorParameter2);
       }
-      this->currentPacket.deletePacket();
+      store->deleteData(message.getStorageId());
       errorParameter1 = 0;
       errorParameter2 = 0;
     } else if (status == MessageQueueIF::EMPTY) {
@@ -92,9 +100,8 @@ ReturnValue_t PusServiceBase::initialize() {
   if (result != RETURN_OK) {
     return result;
   }
-  AcceptsTelemetryIF* destService =
-      ObjectManager::instance()->get<AcceptsTelemetryIF>(packetDestination);
-  PUSDistributorIF* distributor = ObjectManager::instance()->get<PUSDistributorIF>(packetSource);
+  auto* destService = ObjectManager::instance()->get<AcceptsTelemetryIF>(packetDestination);
+  auto* distributor = ObjectManager::instance()->get<PUSDistributorIF>(packetSource);
   if (destService == nullptr or distributor == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "PusServiceBase::PusServiceBase: Service " << this->serviceId

src/fsfw/tmtcservices/PusServiceBase.h

@@ -9,12 +9,13 @@
 #include "fsfw/objectmanager/SystemObject.h"
 #include "fsfw/returnvalues/HasReturnvaluesIF.h"
 #include "fsfw/tasks/ExecutableObjectIF.h"
-#include "fsfw/tmtcpacket/pus/tc.h"
 
 namespace Factory {
 void setStaticFrameworkObjectIds();
 }
 
+class StorageManagerIF;
+
 /**
  * @defgroup pus_services PUS Service Framework
  * These group contains all implementations of PUS Services in the OBSW.
@@ -50,11 +51,12 @@ class PusServiceBase : public ExecutableObjectIF,
    * @param setServiceId
    * The Service Identifier as specified in ECSS PUS.
    */
-  PusServiceBase(object_id_t setObjectId, uint16_t setApid, uint8_t setServiceId);
+  PusServiceBase(object_id_t setObjectId, uint16_t setApid, uint8_t setServiceId,
+                 StorageManagerIF* store);
   /**
    * The destructor is empty.
    */
-  virtual ~PusServiceBase();
+  ~PusServiceBase() override;
   /**
    * @brief 	The handleRequest method shall handle any kind of Telecommand
    * 			Request immediately.
@@ -97,12 +99,12 @@ class PusServiceBase : public ExecutableObjectIF,
    * 			@c RETURN_FAILED else.
    */
   ReturnValue_t performOperation(uint8_t opCode) override;
-  virtual uint16_t getIdentifier() override;
+  uint16_t getIdentifier() override;
   MessageQueueId_t getRequestQueue() override;
-  virtual ReturnValue_t initialize() override;
+  ReturnValue_t initialize() override;
 
-  virtual void setTaskIF(PeriodicTaskIF* taskHandle) override;
-  virtual ReturnValue_t initializeAfterTaskCreation() override;
+  void setTaskIF(PeriodicTaskIF* taskHandle) override;
+  ReturnValue_t initializeAfterTaskCreation() override;
 
  protected:
   /**
@@ -141,7 +143,9 @@ class PusServiceBase : public ExecutableObjectIF,
    * The current Telecommand to be processed.
    * It is deleted after handleRequest was executed.
    */
-  TcPacketStoredPus currentPacket;
+  // TcPacketStoredPus currentPacket;
+  StorageManagerIF* store;
+  PusTcReader currentPacket;
 
   static object_id_t packetSource;
 

src/fsfw/tmtcservices/VerificationReporter.cpp

@@ -11,9 +11,9 @@ object_id_t VerificationReporter::messageReceiver = objects::PUS_SERVICE_1_VERIF
 
 VerificationReporter::VerificationReporter() : acknowledgeQueue(MessageQueueIF::NO_QUEUE) {}
 
-VerificationReporter::~VerificationReporter() {}
+VerificationReporter::~VerificationReporter() = default;
 
-void VerificationReporter::sendSuccessReport(uint8_t set_report_id, TcPacketPusBase* currentPacket,
+void VerificationReporter::sendSuccessReport(uint8_t set_report_id, PusTcReader* currentPacket,
                                              uint8_t set_step) {
   if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
     this->initialize();
@@ -50,7 +50,7 @@ void VerificationReporter::sendSuccessReport(uint8_t set_report_id, uint8_t ackF
   }
 }
 
-void VerificationReporter::sendFailureReport(uint8_t report_id, TcPacketPusBase* currentPacket,
+void VerificationReporter::sendFailureReport(uint8_t report_id, PusTcReader* currentPacket,
                                              ReturnValue_t error_code, uint8_t step,
                                              uint32_t parameter1, uint32_t parameter2) {
   if (acknowledgeQueue == MessageQueueIF::NO_QUEUE) {
@@ -98,8 +98,7 @@ void VerificationReporter::initialize() {
 #endif
     return;
   }
-  AcceptsVerifyMessageIF* temp =
-      ObjectManager::instance()->get<AcceptsVerifyMessageIF>(messageReceiver);
+  auto* temp = ObjectManager::instance()->get<AcceptsVerifyMessageIF>(messageReceiver);
   if (temp == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
     sif::error << "VerificationReporter::initialize: Message "

src/fsfw/tmtcservices/VerificationReporter.h

@@ -3,6 +3,7 @@
 
 #include "PusVerificationReport.h"
 #include "fsfw/objectmanager/ObjectManagerIF.h"
+#include "fsfw/tmtcpacket/pus/tc/PusTcCreator.h"
 
 namespace Factory {
 void setStaticFrameworkObjectIds();
@@ -26,12 +27,11 @@ class VerificationReporter {
   VerificationReporter();
   virtual ~VerificationReporter();
 
-  void sendSuccessReport(uint8_t set_report_id, TcPacketPusBase* current_packet,
-                         uint8_t set_step = 0);
+  void sendSuccessReport(uint8_t set_report_id, PusTcReader* current_packet, uint8_t set_step = 0);
   void sendSuccessReport(uint8_t set_report_id, uint8_t ackFlags, uint16_t tcPacketId,
                          uint16_t tcSequenceControl, uint8_t set_step = 0);
 
-  void sendFailureReport(uint8_t report_id, TcPacketPusBase* current_packet,
+  void sendFailureReport(uint8_t report_id, PusTcReader* current_packet,
                          ReturnValue_t error_code = 0, uint8_t step = 0, uint32_t parameter1 = 0,
                          uint32_t parameter2 = 0);
   void sendFailureReport(uint8_t report_id, uint8_t ackFlags, uint16_t tcPacketId,