sth broke

pus/Service17Test.cpp

@@ -17,14 +17,14 @@ Service17Test::~Service17Test() {
 ReturnValue_t Service17Test::handleRequest(uint8_t subservice) {
 	switch(subservice) {
 	case Subservice::CONNECTION_TEST: {
-		TmPacketStored connectionPacket(apid, serviceId,
+		TmPacketStoredPusA connectionPacket(apid, serviceId,
 		        Subservice::CONNECTION_TEST_REPORT, packetSubCounter++);
 		connectionPacket.sendPacket(requestQueue->getDefaultDestination(),
 				requestQueue->getId());
 		return HasReturnvaluesIF::RETURN_OK;
 	}
     case Subservice::EVENT_TRIGGER_TEST: {
-        TmPacketStored connectionPacket(apid, serviceId,
+        TmPacketStoredPusA connectionPacket(apid, serviceId,
                 Subservice::CONNECTION_TEST_REPORT, packetSubCounter++);
         connectionPacket.sendPacket(requestQueue->getDefaultDestination(),
                 requestQueue->getId());

pus/Service1TelecommandVerification.cpp

@@ -68,7 +68,7 @@ ReturnValue_t Service1TelecommandVerification::generateFailureReport(
 			message->getTcSequenceControl(), message->getStep(),
 			message->getErrorCode(), message->getParameter1(),
 			message->getParameter2());
-	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	TmPacketStoredPusA tmPacket(apid, serviceId, message->getReportId(),
 	        packetSubCounter++, &report);
 	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
 			tmQueue->getId());
@@ -79,7 +79,7 @@ ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
         PusVerificationMessage *message) {
 	SuccessReport report(message->getReportId(),message->getTcPacketId(),
 			message->getTcSequenceControl(),message->getStep());
-	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
+	TmPacketStoredPusA tmPacket(apid, serviceId, message->getReportId(),
 	        packetSubCounter++, &report);
 	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
 			tmQueue->getId());

pus/Service5EventReporting.cpp

@@ -52,7 +52,7 @@ ReturnValue_t Service5EventReporting::generateEventReport(
 {
 	EventReport report(message.getEventId(),message.getReporter(),
 			message.getParameter1(),message.getParameter2());
-	TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
+	TmPacketStoredPusA tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
 			message.getSeverity(), packetSubCounter++, &report);
 	ReturnValue_t result = tmPacket.sendPacket(
 	        requestQueue->getDefaultDestination(),requestQueue->getId());

tmtcpacket/pus/CMakeLists.txt

@@ -7,4 +7,5 @@ target_sources(${LIB_FSFW_NAME}
 		TmPacketStored.cpp
 		TmPacketPusA.cpp
 		TmPacketPusC.cpp
+		TmPacketStoredBase.cpp
 )

tmtcpacket/pus/TmPacketBase.h

@@ -31,7 +31,7 @@ public:
     static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048;
     //! First byte of secondary header for PUS-A packets.
     //! TODO: Maybe also support PUS-C via config?
-    static const uint8_t VERSION_NUMBER_BYTE_PUS_A = 0b00010000;
+    static const uint8_t VERSION_NUMBER_BYTE = 0b00010000;
 
     /**
      * This is the default constructor.

tmtcpacket/pus/TmPacketPusA.cpp

@@ -11,7 +11,7 @@
 
 
 TmPacketPusA::TmPacketPusA(uint8_t* setData) : TmPacketBase(setData) {
-    tmData = reinterpret_cast<TmPacketPointer*>(setData);
+    tmData = reinterpret_cast<TmPacketPointerPusA*>(setData);
 }
 
 TmPacketPusA::~TmPacketPusA() {
@@ -35,23 +35,9 @@ uint16_t TmPacketPusA::getSourceDataSize() {
             - CRC_SIZE + 1;
 }
 
-//uint16_t TmPacketPusA::getErrorControl() {
-//    uint32_t size = getSourceDataSize() + CRC_SIZE;
-//    uint8_t* p_to_buffer = &tmData->data;
-//    return (p_to_buffer[size - 2] << 8) + p_to_buffer[size - 1];
-//}
-//
-//void TmPacketPusA::setErrorControl() {
-//    uint32_t full_size = getFullSize();
-//    uint16_t crc = CRC::crc16ccitt(getWholeData(), full_size - CRC_SIZE);
-//    uint32_t size = getSourceDataSize();
-//    getSourceData()[size] = (crc & 0XFF00) >> 8;    // CRCH
-//    getSourceData()[size + 1] = (crc) & 0X00FF;         // CRCL
-//}
-
 void TmPacketPusA::setData(const uint8_t* p_Data) {
     SpacePacketBase::setData(p_Data);
-    tmData = (TmPacketPointer*) p_Data;
+    tmData = (TmPacketPointerPusA*) p_Data;
 }
 
 
@@ -60,7 +46,7 @@ size_t TmPacketPusA::getPacketMinimumSize() const {
 }
 
 uint16_t TmPacketPusA::getDataFieldSize() {
-    return sizeof(PUSTmDataFieldHeader);
+    return sizeof(PUSTmDataFieldHeaderPusA);
 }
 
 bool TmPacketPusA::checkAndSetStamper() {
@@ -113,7 +99,7 @@ void TmPacketPusA::initializeTmPacket(uint16_t apid, uint8_t service,
 }
 
 void TmPacketPusA::setSourceDataSize(uint16_t size) {
-    setPacketDataLength(size + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+    setPacketDataLength(size + sizeof(PUSTmDataFieldHeaderPusA) + CRC_SIZE - 1);
 }
 
 size_t TmPacketPusA::getTimestampSize() const {

tmtcpacket/pus/TmPacketPusA.h

@@ -18,7 +18,7 @@ void setStaticFrameworkObjectIds();
  * for a time tag.
  * @ingroup tmtcpackets
  */
-struct PUSTmDataFieldHeader {
+struct PUSTmDataFieldHeaderPusA {
     uint8_t version_type_ack;
     uint8_t service_type;
     uint8_t service_subtype;
@@ -32,9 +32,9 @@ struct PUSTmDataFieldHeader {
  * accessed via a pointer.
  * @ingroup tmtcpackets
  */
-struct TmPacketPointer {
+struct TmPacketPointerPusA {
     CCSDSPrimaryHeader primary;
-    PUSTmDataFieldHeader data_field;
+    PUSTmDataFieldHeaderPusA data_field;
     uint8_t data;
 };
 
@@ -49,7 +49,7 @@ public:
      * This constant defines the minimum size of a valid PUS Telemetry Packet.
      */
     static const uint32_t  TM_PACKET_MIN_SIZE = (sizeof(CCSDSPrimaryHeader) +
-            sizeof(PUSTmDataFieldHeader) + 2);
+            sizeof(PUSTmDataFieldHeaderPusA) + 2);
     //! Maximum size of a TM Packet in this mission.
     //! TODO: Make this dependant on a config variable.
     static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048;
@@ -75,6 +75,7 @@ public:
     uint8_t* getSourceData() override;
     uint16_t getSourceDataSize() override;
     uint16_t getDataFieldSize() override;
+
     /**
      * Interprets the "time"-field in the secondary header and returns it in
      * timeval format.
@@ -97,7 +98,7 @@ protected:
      *
      * To be hardware-safe, all elements are of byte size.
      */
-    TmPacketPointer* tmData;
+    TmPacketPointerPusA* tmData;
 
     /**
      * Initializes the Tm Packet header.

tmtcpacket/pus/TmPacketStored.cpp

@@ -6,20 +6,19 @@
 
 #include <cstring>
 
-StorageManagerIF *TmPacketStored::store = nullptr;
+StorageManagerIF *TmPacketStoredPusA::store = nullptr;
-InternalErrorReporterIF *TmPacketStored::internalErrorReporter = nullptr;
+InternalErrorReporterIF *TmPacketStoredPusA::internalErrorReporter = nullptr;
 
-TmPacketStored::TmPacketStored(store_address_t setAddress) :
+TmPacketStoredPusA::TmPacketStoredPusA(store_address_t setAddress) :
-		TmPacketPusA(nullptr), storeAddress(setAddress) {
+		TmPacketStoredBase(setAddress), TmPacketPusA(nullptr){
-	setStoreAddress(storeAddress);
 }
 
-TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
+TmPacketStoredPusA::TmPacketStoredPusA(uint16_t apid, uint8_t service,
 		uint8_t subservice, uint8_t packetSubcounter, const uint8_t *data,
 		uint32_t size, const uint8_t *headerData, uint32_t headerSize) :
 		TmPacketPusA(nullptr) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (not checkAndSetStore()) {
+	if (not TmPacketStoredBase::checkAndSetStore()) {
 		return;
 	}
 	uint8_t *pData = nullptr;
@@ -27,7 +26,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 			(getPacketMinimumSize() + size + headerSize), &pData);
 
 	if (returnValue != store->RETURN_OK) {
-		checkAndReportLostTm();
+	    TmPacketStoredBase::checkAndReportLostTm();
 		return;
 	}
 	setData(pData);
@@ -35,15 +34,15 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	memcpy(getSourceData(), headerData, headerSize);
 	memcpy(getSourceData() + headerSize, data, size);
 	setPacketDataLength(
-			size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+			size + headerSize + sizeof(PUSTmDataFieldHeaderPusA) + CRC_SIZE - 1);
 }
 
-TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
+TmPacketStoredPusA::TmPacketStoredPusA(uint16_t apid, uint8_t service,
 		uint8_t subservice, uint8_t packetSubcounter, SerializeIF *content,
 		SerializeIF *header) :
 		TmPacketPusA(nullptr) {
 	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	if (not checkAndSetStore()) {
+	if (not  TmPacketStoredBase::checkAndSetStore()) {
 		return;
 	}
 	size_t sourceDataSize = 0;
@@ -57,7 +56,7 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 	ReturnValue_t returnValue = store->getFreeElement(&storeAddress,
 			(getPacketMinimumSize() + sourceDataSize), &p_data);
 	if (returnValue != store->RETURN_OK) {
-		checkAndReportLostTm();
+	    TmPacketStoredBase::checkAndReportLostTm();
 	}
 	setData(p_data);
 	initializeTmPacket(apid, service, subservice, packetSubcounter);
@@ -72,76 +71,13 @@ TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
 				SerializeIF::Endianness::BIG);
 	}
 	setPacketDataLength(
-			sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE - 1);
+			sourceDataSize + sizeof(PUSTmDataFieldHeaderPusA) + CRC_SIZE - 1);
 }
 
-store_address_t TmPacketStored::getStoreAddress() {
+uint8_t* TmPacketStoredPusA::getAllTmData() {
-	return storeAddress;
+    return getWholeData();
 }
 
-void TmPacketStored::deletePacket() {
+void TmPacketStoredPusA::setDataPointer(const uint8_t *newPointer) {
-	store->deleteData(storeAddress);
+    setData(newPointer);
-	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	setData(nullptr);
-}
-
-void TmPacketStored::setStoreAddress(store_address_t setAddress) {
-	storeAddress = setAddress;
-	const uint8_t* tempData = nullptr;
-	size_t tempSize;
-	if (not checkAndSetStore()) {
-		return;
-	}
-	ReturnValue_t status = store->getData(storeAddress, &tempData, &tempSize);
-	if (status == StorageManagerIF::RETURN_OK) {
-		setData(tempData);
-	} else {
-		setData(nullptr);
-		storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
-	}
-}
-
-bool TmPacketStored::checkAndSetStore() {
-	if (store == nullptr) {
-		store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
-		if (store == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
-					<< std::endl;
-#endif
-			return false;
-		}
-	}
-	return true;
-}
-
-ReturnValue_t TmPacketStored::sendPacket(MessageQueueId_t destination,
-		MessageQueueId_t sentFrom, bool doErrorReporting) {
-	if (getWholeData() == nullptr) {
-		//SHOULDDO: More decent code.
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-	TmTcMessage tmMessage(getStoreAddress());
-	ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
-			&tmMessage, sentFrom);
-	if (result != HasReturnvaluesIF::RETURN_OK) {
-		deletePacket();
-		if (doErrorReporting) {
-			checkAndReportLostTm();
-		}
-		return result;
-	}
-	//SHOULDDO: In many cases, some counter is incremented for successfully sent packets. The check is often not done, but just incremented.
-	return HasReturnvaluesIF::RETURN_OK;
-
-}
-
-void TmPacketStored::checkAndReportLostTm() {
-	if (internalErrorReporter == nullptr) {
-		internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
-				objects::INTERNAL_ERROR_REPORTER);
-	}
-	if (internalErrorReporter != nullptr) {
-		internalErrorReporter->lostTm();
-	}
 }

tmtcpacket/pus/TmPacketStored.h

@@ -1,7 +1,8 @@
-#ifndef FSFW_TMTCPACKET_PUS_TMPACKETSTORED_H_
+#ifndef FSFW_TMTCPACKET_PUS_TMPACKETSTORED_PUSA_H_
-#define FSFW_TMTCPACKET_PUS_TMPACKETSTORED_H_
+#define FSFW_TMTCPACKET_PUS_TMPACKETSTORED_PUSA_H_
 
 #include "TmPacketBase.h"
+#include "TmPacketStoredBase.h"
 #include <FSFWConfig.h>
 
 #include "../../tmtcpacket/pus/TmPacketPusA.h"
@@ -20,13 +21,15 @@
  *	packets in a store with the help of a storeAddress.
  *	@ingroup tmtcpackets
  */
-class TmPacketStored : public TmPacketPusA {
+class TmPacketStoredPusA :
+        public TmPacketStoredBase,
+        public TmPacketPusA {
 public:
 	/**
 	 * This is a default constructor which does not set the data pointer.
 	 * However, it does try to set the packet store.
 	 */
-	TmPacketStored( store_address_t setAddress );
+	TmPacketStoredPusA( store_address_t setAddress );
 	/**
 	 * With this constructor, new space is allocated in the packet store and
 	 * a new PUS Telemetry Packet is created there.
@@ -47,7 +50,7 @@ public:
 	 * 						 will be copied in front of data
 	 * @param headerSize	The size of the headerDataF
 	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice,
+	TmPacketStoredPusA( uint16_t apid, uint8_t service,	uint8_t subservice,
 			uint8_t packet_counter = 0, const uint8_t* data = nullptr,
 			uint32_t size = 0, const uint8_t* headerData = nullptr,
 			uint32_t headerSize = 0);
@@ -55,30 +58,13 @@ public:
 	 * Another ctor to directly pass structured content and header data to the
 	 * packet to avoid additional buffers.
 	 */
-	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice,
+	TmPacketStoredPusA( uint16_t apid, uint8_t service,	uint8_t subservice,
 			uint8_t packet_counter, SerializeIF* content,
 			SerializeIF* header = nullptr);
-	/**
-	 * This is a getter for the current store address of the packet.
-	 * @return	The current store address. The (raw) value is
-	 * 			@c StorageManagerIF::INVALID_ADDRESS if
-	 * 			the packet is not linked.
-	 */
-	store_address_t getStoreAddress();
-	/**
-	 * With this call, the packet is deleted.
-	 * It removes itself from the store and sets its data pointer to NULL.
-	 */
-	void deletePacket();
-	/**
-	 * With this call, a packet can be linked to another store. This is useful
-	 * if the packet is a class member and used for more than one packet.
-	 * @param setAddress	The new packet id to link to.
-	 */
-	void setStoreAddress( store_address_t setAddress );
 
-	ReturnValue_t sendPacket( MessageQueueId_t destination,
+    uint8_t* getAllTmData() override;
-			MessageQueueId_t sentFrom, bool doErrorReporting = true );
+    void setDataPointer(const uint8_t* newPointer) override;
+
 private:
 	/**
 	 * This is a pointer to the store all instances of the class use.
@@ -94,17 +80,7 @@ private:
 	 * 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.
-	 */
-	bool checkAndSetStore();
-
-	void checkAndReportLostTm();
 };
 
 
-#endif /* FSFW_TMTCPACKET_PUS_TMPACKETSTORED_H_ */
+#endif /* FSFW_TMTCPACKET_PUS_TMPACKETSTORED_PUSA_H_ */

tmtcpacket/pus/TmPacketStoredBase.cpp

@@ -0,0 +1,94 @@
+#include "TmPacketStoredBase.h"
+
+#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../tmtcservices/TmTcMessage.h"
+
+#include <cstring>
+
+StorageManagerIF *TmPacketStoredBase::store = nullptr;
+InternalErrorReporterIF *TmPacketStoredBase::internalErrorReporter = nullptr;
+
+TmPacketStoredBase::TmPacketStoredBase(store_address_t setAddress): storeAddress(setAddress) {
+    setStoreAddress(storeAddress);
+}
+
+TmPacketStoredBase::TmPacketStoredBase() {
+}
+
+
+TmPacketStoredBase::~TmPacketStoredBase() {
+}
+
+store_address_t TmPacketStoredBase::getStoreAddress() {
+    return storeAddress;
+}
+
+void TmPacketStoredBase::deletePacket() {
+    store->deleteData(storeAddress);
+    storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+    setDataPointer(nullptr);
+}
+
+void TmPacketStoredBase::setStoreAddress(store_address_t setAddress) {
+    storeAddress = setAddress;
+    const uint8_t* tempData = nullptr;
+    size_t tempSize;
+    if (not checkAndSetStore()) {
+        return;
+    }
+    ReturnValue_t status = store->getData(storeAddress, &tempData, &tempSize);
+    if (status == StorageManagerIF::RETURN_OK) {
+        setDataPointer(tempData);
+    } else {
+        setDataPointer(nullptr);
+        storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+    }
+}
+
+bool TmPacketStoredBase::checkAndSetStore() {
+    if (store == nullptr) {
+        store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
+        if (store == nullptr) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+            sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
+                    << std::endl;
+#endif
+            return false;
+        }
+    }
+    return true;
+}
+
+ReturnValue_t TmPacketStoredBase::sendPacket(MessageQueueId_t destination,
+        MessageQueueId_t sentFrom, bool doErrorReporting) {
+    if (getAllTmData() == nullptr) {
+        //SHOULDDO: More decent code.
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    TmTcMessage tmMessage(getStoreAddress());
+    ReturnValue_t result = MessageQueueSenderIF::sendMessage(destination,
+            &tmMessage, sentFrom);
+    if (result != HasReturnvaluesIF::RETURN_OK) {
+        deletePacket();
+        if (doErrorReporting) {
+            checkAndReportLostTm();
+        }
+        return result;
+    }
+    //SHOULDDO: In many cases, some counter is incremented for successfully sent packets. The check is often not done, but just incremented.
+    return HasReturnvaluesIF::RETURN_OK;
+
+}
+
+void TmPacketStoredBase::checkAndReportLostTm() {
+    if (internalErrorReporter == nullptr) {
+        internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+                objects::INTERNAL_ERROR_REPORTER);
+    }
+    if (internalErrorReporter != nullptr) {
+        internalErrorReporter->lostTm();
+    }
+}
+
+

tmtcpacket/pus/TmPacketStoredBase.h

@@ -0,0 +1,89 @@
+#ifndef FSFW_TMTCPACKET_PUS_TMPACKETSTOREDBASE_H_
+#define FSFW_TMTCPACKET_PUS_TMPACKETSTOREDBASE_H_
+
+#include "TmPacketBase.h"
+#include "TmPacketStoredBase.h"
+#include <FSFWConfig.h>
+
+#include "../../tmtcpacket/pus/TmPacketPusA.h"
+#include "../../serialize/SerializeIF.h"
+#include "../../storagemanager/StorageManagerIF.h"
+#include "../../internalError/InternalErrorReporterIF.h"
+#include "../../ipc/MessageQueueSenderIF.h"
+
+/**
+ *  This class generates a ECSS PUS Telemetry packet within a given
+ *  intermediate storage.
+ *  As most packets are passed between tasks with the help of a storage
+ *  anyway, it seems logical to create a Packet-In-Storage access class
+ *  which saves the user almost all storage handling operation.
+ *  Packets can both be newly created with the class and be "linked" to
+ *  packets in a store with the help of a storeAddress.
+ *  @ingroup tmtcpackets
+ */
+class TmPacketStoredBase {
+public:
+    /**
+     * This is a default constructor which does not set the data pointer.
+     * However, it does try to set the packet store.
+     */
+    TmPacketStoredBase( store_address_t setAddress );
+    TmPacketStoredBase();
+
+    virtual ~TmPacketStoredBase();
+
+    virtual uint8_t* getAllTmData() = 0;
+    virtual void setDataPointer(const uint8_t* newPointer) = 0;
+
+    /**
+     * This is a getter for the current store address of the packet.
+     * @return  The current store address. The (raw) value is
+     *          @c StorageManagerIF::INVALID_ADDRESS if
+     *          the packet is not linked.
+     */
+    store_address_t getStoreAddress();
+    /**
+     * With this call, the packet is deleted.
+     * It removes itself from the store and sets its data pointer to NULL.
+     */
+    void deletePacket();
+    /**
+     * With this call, a packet can be linked to another store. This is useful
+     * if the packet is a class member and used for more than one packet.
+     * @param setAddress    The new packet id to link to.
+     */
+    void setStoreAddress( store_address_t setAddress );
+
+    ReturnValue_t sendPacket( MessageQueueId_t destination,
+            MessageQueueId_t sentFrom, bool doErrorReporting = true );
+
+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::TM_STORE.
+     */
+    static StorageManagerIF* store;
+
+    static InternalErrorReporterIF *internalErrorReporter;
+
+    /**
+     * 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.
+     */
+    bool checkAndSetStore();
+
+    void checkAndReportLostTm();
+};
+
+
+#endif /* FSFW_TMTCPACKET_PUS_TMPACKETSTOREDBASE_H_ */
+

tmtcservices/CommandingServiceBase.cpp

@@ -293,7 +293,7 @@ void CommandingServiceBase::handleRequestQueue() {
 ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
 		const uint8_t* data, size_t dataLen, const uint8_t* headerData,
 		size_t headerSize) {
-	TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+	TmPacketStoredPusA tmPacketStored(this->apid, this->service, subservice,
 			this->tmPacketCounter, data, dataLen, headerData, headerSize);
 	ReturnValue_t result = tmPacketStored.sendPacket(
 			requestQueue->getDefaultDestination(), requestQueue->getId());
@@ -311,7 +311,7 @@ ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
     size_t size = 0;
     SerializeAdapter::serialize(&objectId, &pBuffer, &size,
                 sizeof(object_id_t), SerializeIF::Endianness::BIG);
-    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+    TmPacketStoredPusA tmPacketStored(this->apid, this->service, subservice,
             this->tmPacketCounter, data, dataLen, buffer, size);
     ReturnValue_t result = tmPacketStored.sendPacket(
             requestQueue->getDefaultDestination(), requestQueue->getId());
@@ -324,7 +324,7 @@ ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
 
 ReturnValue_t CommandingServiceBase::sendTmPacket(uint8_t subservice,
         SerializeIF* content, SerializeIF* header) {
-    TmPacketStored tmPacketStored(this->apid, this->service, subservice,
+    TmPacketStoredPusA tmPacketStored(this->apid, this->service, subservice,
             this->tmPacketCounter, content, header);
     ReturnValue_t result = tmPacketStored.sendPacket(
             requestQueue->getDefaultDestination(), requestQueue->getId());

unittest/user/unittest/core/CatchFactory.cpp

@@ -74,7 +74,7 @@ void Factory::setStaticFrameworkObjectIds() {
 
 	DeviceHandlerFailureIsolation::powerConfirmationId = objects::NO_OBJECT;
 
-	TmPacketStored::timeStamperId = objects::NO_OBJECT;
+	TmPacketStoredPusA::timeStamperId = objects::NO_OBJECT;
 }