Today's the day. Renamed platform to framework.

tmtcpacket/Makefile

@@ -0,0 +1,24 @@
+#!/bin/bash
+#
+# OSAL makefile
+#
+#  Created on: Mar 04, 2010
+#      Author: ziemke
+#      Author: Claas Ziemke
+#      Copyright 2010, Claas Ziemke <claas.ziemke@gmx.net>
+#
+
+BASEDIR=../../
+include $(BASEDIR)options.mk
+
+OBJ = 		$(BUILDDIR)/SpacePacketBase.o \
+			$(BUILDDIR)/SpacePacket.o
+
+
+all: $(OBJ)
+	 		
+$(BUILDDIR)/%.o: %.cpp %.h
+	$(CPP) $(CFLAGS) $(DEFINES) $(CCOPT) ${INCLUDE} -c $< -o $@
+
+clean:
+	$(RM) *.o *.gcno *.gcda

tmtcpacket/SpacePacket.cpp

@@ -0,0 +1,39 @@
+/*
+ * SpacePacket.cpp
+ *
+ *  Created on: Mar 23, 2012
+ *      Author: baetz
+ */
+
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tmtcpacket/ccsds_header.h>
+#include <framework/tmtcpacket/SpacePacket.h>
+#include <string.h>
+
+SpacePacket::SpacePacket(  uint16_t set_packet_data_length, uint8_t set_type, uint16_t new_apid, uint16_t set_count  ):
+SpacePacketBase( (uint8_t*)&this->local_data ) {
+	//reset everything to zero:
+	memset(this->local_data.byteStream,0 , sizeof(this->local_data.byteStream) );
+	//Primary header:
+	this->local_data.fields.header.packet_id_h = 0b00000000 + ( (set_type & 0b1) << 4 );
+	this->setAPID( new_apid );
+	this->local_data.fields.header.sequence_control_h = 0b11000000;
+	this->setPacketSequenceCount(set_count);
+	if ( set_packet_data_length <= sizeof(this->local_data.fields.buffer) ) {
+		this->setPacketDataLength(set_packet_data_length);
+	} else {
+		this->setPacketDataLength( sizeof(this->local_data.fields.buffer) );
+	}
+}
+
+SpacePacket::~SpacePacket( void ) {
+}
+
+bool SpacePacket::addWholeData( const uint8_t* p_Data, uint32_t packet_size ) {
+	if ( packet_size <= sizeof(this->data) ) {
+		memcpy( &this->local_data.byteStream, p_Data, packet_size );
+		return true;
+	} else {
+		return false;
+	}
+}

tmtcpacket/SpacePacket.h

@@ -0,0 +1,72 @@
+#ifndef SPACEPACKET_H_
+#define SPACEPACKET_H_
+
+#include <framework/tmtcpacket/SpacePacketBase.h>
+
+/**
+ * The SpacePacket class is a representation of a simple CCSDS Space Packet
+ * without (control over) a secondary header.
+ * It can be instantiated with a size smaller than \c PACKET_MAX_SIZE. Its
+ * main use is to serve as an idle packet in case no other packets are sent.
+ * For the ECSS PUS part the TcPacket and TmPacket classes are used.
+ * A pointer to \c local_data is passed to the \c SpacePacketBase parent class,
+ * so the parent's methods are reachable.
+ * @ingroup tmtcpackets
+ */
+class SpacePacket : public SpacePacketBase {
+	public:
+	static const uint16_t PACKET_MAX_SIZE =  1024;
+	/**
+	 * The constructor initializes the packet and sets all header information
+	 * according to the passed parameters.
+	 * @param set_packet_data_length 	Sets the packet data length field and
+	 * 			therefore specifies the size of the packet.
+	 * @param set_type	Sets the packet type field to either 0 (TM) or 1 (TC).
+	 * @param set_apid	Sets the packet's APID field. The default value
+	 * 			describes an idle packet.
+	 * @param set_sequence_count	Sets the packet's Source Sequence Count
+	 * 			field.
+	 */
+	SpacePacket( uint16_t set_packet_data_length, uint8_t set_type = 0, uint16_t set_apid = APID_IDLE_PACKET, uint16_t set_sequence_count = 0 );
+	/**
+	 * The class's default destructor.
+	 */
+	virtual ~SpacePacket();
+	/**
+	 * With this call, the complete data content (including the CCSDS Primary
+	 * Header) is overwritten with the byte stream given.
+	 * @param p_data		Pointer to data to overwrite the content with
+	 * @param packet_size	Size of the data
+	 * @return	@li	\c true if packet_size is smaller than \c MAX_PACKET_SIZE.
+	 * 			@li \c false else.
+	 */
+	bool addWholeData( const uint8_t* p_data, uint32_t packet_size );
+protected:
+	/**
+	 * This structure defines the data structure of a Space Packet as local data.
+	 * There's a buffer which corresponds to the Space Packet Data Field with a
+	 * maximum size of \c PACKET_MAX_SIZE.
+	 */
+	struct PacketStructured {
+		CCSDSPrimaryHeader header;
+		uint8_t buffer[PACKET_MAX_SIZE];
+	};
+	/**
+	 * This union simplifies accessing the full data content of the Space Packet.
+	 * This is achieved by putting the \c PacketStructured struct in a union with
+	 * a plain buffer.
+	 */
+	union SpacePacketData {
+		PacketStructured fields;
+		uint8_t byteStream[PACKET_MAX_SIZE + sizeof(CCSDSPrimaryHeader)];
+	};
+	/**
+	 * This is the data representation of the class.
+	 * It is a struct of CCSDS Primary Header and a data field, which again is
+	 * packed in an union, so the data can be accessed as a byte stream without
+	 * a cast.
+	 */
+	SpacePacketData local_data;
+};
+
+#endif /* SPACEPACKET_H_ */

tmtcpacket/SpacePacketBase.cpp

@@ -0,0 +1,85 @@
+/*
+ * SpacePacketBase.cpp
+ *
+ *  Created on: 21.03.2012
+ *      Author: baetz
+ */
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tmtcpacket/SpacePacketBase.h>
+SpacePacketBase::SpacePacketBase( const uint8_t* set_address ) {
+	this->data = (SpacePacketPointer*) set_address;
+}
+
+SpacePacketBase::~SpacePacketBase() {
+};
+
+//CCSDS Methods:
+uint8_t SpacePacketBase::getPacketVersionNumber( void ) {
+	return (this->data->header.packet_id_h & 0b11100000) >> 5;
+}
+
+bool SpacePacketBase::isTelecommand( void ) {
+	return (this->data->header.packet_id_h & 0b00010000) >> 4;
+}
+
+bool SpacePacketBase::hasSecondaryHeader( void ) {
+	return (this->data->header.packet_id_h & 0b00001000) >> 3;
+}
+
+uint16_t SpacePacketBase::getPacketId() {
+	return ( (this->data->header.packet_id_h) << 8 ) +
+			this->data->header.packet_id_l;
+}
+
+uint16_t SpacePacketBase::getAPID( void ) {
+	return ( (this->data->header.packet_id_h & 0b00000111) << 8 ) +
+			this->data->header.packet_id_l;
+}
+
+void SpacePacketBase::setAPID( uint16_t new_apid ) {
+	//Use first three bits of new APID, but keep rest of packet id as it was (see specification).
+	this->data->header.packet_id_h = (this->data->header.packet_id_h & 0b11111000) | ( ( new_apid & 0x0700 ) >> 8 );
+	this->data->header.packet_id_l = ( new_apid & 0x00FF );
+}
+
+uint16_t SpacePacketBase::getPacketSequenceControl( void ) {
+	return ( (this->data->header.sequence_control_h) << 8 )
+		+ this->data->header.sequence_control_l;
+}
+
+uint8_t SpacePacketBase::getSequenceFlags( void ) {
+	return (this->data->header.sequence_control_h & 0b11000000) >> 6 ;
+}
+
+uint16_t SpacePacketBase::getPacketSequenceCount( void ) {
+	return ( (this->data->header.sequence_control_h & 0b00111111) << 8 )
+		+ this->data->header.sequence_control_l;
+}
+
+void SpacePacketBase::setPacketSequenceCount( uint16_t new_count) {
+	this->data->header.sequence_control_h = ( this->data->header.sequence_control_h & 0b11000000 ) | ( ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x3F00 ) >> 8 );
+	this->data->header.sequence_control_l = ( (new_count%LIMIT_SEQUENCE_COUNT) & 0x00FF );
+}
+
+uint16_t SpacePacketBase::getPacketDataLength( void ) {
+	return ( (this->data->header.packet_length_h) << 8 )
+		+ this->data->header.packet_length_l;
+}
+
+void SpacePacketBase::setPacketDataLength( uint16_t new_length) {
+	this->data->header.packet_length_h = ( ( new_length & 0xFF00 ) >> 8 );
+	this->data->header.packet_length_l = ( new_length & 0x00FF );
+}
+
+uint32_t SpacePacketBase::getFullSize() {
+	//+1 is done because size in packet data length field is: size of data field -1
+	return this->getPacketDataLength() + sizeof(this->data->header) + 1;
+}
+
+uint8_t* SpacePacketBase::getWholeData() {
+	return (uint8_t*)this->data;
+}
+
+void SpacePacketBase::setData( const uint8_t* p_Data ) {
+	this->data = (SpacePacketPointer*)p_Data;
+}

tmtcpacket/SpacePacketBase.h

@@ -0,0 +1,170 @@
+#ifndef SPACEPACKETBASE_H_
+#define SPACEPACKETBASE_H_
+
+#include <framework/tmtcpacket/ccsds_header.h>
+
+/**
+ * \defgroup tmtcpackets Space Packets
+ * This is the group, where all classes associated with Telecommand and
+ * Telemetry packets belong to.
+ * The class hierarchy resembles the dependency between the different standards
+ * applied, namely the CCSDS Space Packet standard and the ECCSS Packet
+ * Utilization Standard. Most field and structure names are taken from these
+ * standards.
+ */
+
+/**
+ * This struct defines the data structure of a Space Packet when accessed
+ * via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct SpacePacketPointer {
+	CCSDSPrimaryHeader header;
+	uint8_t packet_data;
+};
+
+/**
+ * This class is the basic data handler for any CCSDS Space Packet
+ * compatible Telecommand and Telemetry packet.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * Remark: All bit numbers in this documentation are counted from
+ * the most significant bit (from left).
+ * @ingroup tmtcpackets
+ */
+class SpacePacketBase {
+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;
+public:
+	static const uint16_t LIMIT_APID = 2048; //2^1
+	static const uint16_t LIMIT_SEQUENCE_COUNT = 16384; // 2^14
+	static const uint16_t APID_IDLE_PACKET = 0x7FF;
+	static const uint8_t TELECOMMAND_PACKET = 1;
+	static const uint8_t TELEMETRY_PACKET = 0;
+	/**
+	 * This definition defines the CRC size in byte.
+	 */
+	static const uint8_t CRC_SIZE = 2;
+	/**
+	 * This is the minimum size of a SpacePacket.
+	 */
+	static const uint16_t MINIMUM_SIZE = sizeof(CCSDSPrimaryHeader) + CRC_SIZE;
+	/**
+	 * 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.
+	 */
+	SpacePacketBase( const uint8_t* set_address );
+	/**
+	 * No data is allocated, so the destructor is empty.
+	 */
+	virtual ~SpacePacketBase();
+
+	//CCSDS Methods:
+	/**
+	 * Getter for the packet version number field.
+	 * @return Returns the highest three bit of the packet in one byte.
+	 */
+	uint8_t getPacketVersionNumber( void );
+	/**
+	 * This method checks the type field in the header.
+	 * This bit specifies, if the command is interpreted as Telecommand of
+	 * as Telemetry. For a Telecommand, the bit is set.
+	 * @return Returns true if the bit is set and false if not.
+	 */
+	bool isTelecommand( void );
+	/**
+	 * The CCSDS header provides a secondary header flag (the fifth-highest bit),
+	 *  which is checked with this method.
+	 * @return	Returns true if the bit is set and false if not.
+	 */
+	bool hasSecondaryHeader( void );
+	/**
+	 * Returns the complete first two bytes of the packet, which together form
+	 * the CCSDS packet id.
+	 * @return	The CCSDS packet id.
+	 */
+	uint16_t getPacketId( void );
+	/**
+	 * Returns the APID of a packet, which are the lowest 11 bit of the packet
+	 * id.
+	 * @return The CCSDS APID.
+	 */
+	uint16_t getAPID( void );
+	/**
+	 * Sets the APID of a packet, which are the lowest 11 bit of the packet
+	 * id.
+	 * @param 	The APID to set. The highest five bits of the parameter are
+	 * 			ignored.
+	 */
+	void setAPID( uint16_t setAPID );
+	/**
+	 * Returns the CCSDS packet sequence control field, which are the third and
+	 * the fourth byte of the CCSDS primary header.
+	 * @return The CCSDS packet sequence control field.
+	 */
+	uint16_t getPacketSequenceControl( void );
+	/**
+	 * Returns the SequenceFlags, which are the highest two bit of the packet
+	 * sequence control field.
+	 * @return	The CCSDS sequence flags.
+	 */
+	uint8_t getSequenceFlags( void );
+	/**
+	 * Returns the packet sequence count, which are the lowest 14 bit of the
+	 * packet sequence control field.
+	 * @return The CCSDS sequence count.
+	 */
+	uint16_t getPacketSequenceCount( void );
+	/**
+	 * Sets the packet sequence count, which are the lowest 14 bit of the
+	 * packet sequence control field.
+	 * setCount is modulo-divided by \c LIMIT_SEQUENCE_COUNT to avoid overflows.
+	 * @param setCount	The value to set the count to.
+	 */
+	void setPacketSequenceCount( uint16_t setCount );
+	/**
+	 * Returns the packet data length, which is the fifth and sixth byte of the
+	 * CCSDS Primary Header. The packet data length is the size of every kind
+	 * of data \b after the CCSDS Primary Header \b -1.
+	 * @return The CCSDS packet data length.
+	 */
+	uint16_t getPacketDataLength( void ); //uint16_t is sufficient, because this is limit in CCSDS standard
+	/**
+	 * Sets the packet data length, which is the fifth and sixth byte of the
+	 * CCSDS Primary Header.
+	 * @param setLength The value of the length to set. It must fit the true
+	 * 					CCSDS packet data length . The packet data length is
+	 * 					the size of every kind of data \b after the CCSDS
+	 * 					Primary Header \b -1.
+	 */
+	void setPacketDataLength( uint16_t setLength );
+
+	//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( void );
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 * @param p_Data A pointer to another raw Space Packet.
+	 */
+	virtual void setData( const uint8_t* p_Data );
+	/**
+	 * This method returns the full raw packet size.
+	 * @return	The full size of the packet in bytes.
+	 */
+	uint32_t getFullSize();
+
+};
+
+#endif /* SPACEPACKETBASE_H_ */

tmtcpacket/ccsds_header.h

@@ -0,0 +1,15 @@
+#ifndef CCSDS_HEADER_H_
+#define CCSDS_HEADER_H_
+
+#include <stdint.h>
+
+struct CCSDSPrimaryHeader {
+	uint8_t packet_id_h;
+	uint8_t packet_id_l;
+	uint8_t sequence_control_h;
+	uint8_t sequence_control_l;
+	uint8_t packet_length_h;
+	uint8_t packet_length_l;
+};
+
+#endif /* CCSDS_HEADER_H_ */

tmtcpacket/packetmatcher/ApidMatcher.h

@@ -0,0 +1,44 @@
+/*
+ * ApidMatcher.h
+ *
+ *  Created on: 09.03.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_
+
+#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
+
+class ApidMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+private:
+	uint16_t apid;
+public:
+	ApidMatcher(uint16_t setApid) :
+			apid(setApid) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getAPID() == apid) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const {
+		return SerializeAdapter<uint16_t>::serialize(&apid, buffer, size, max_size, bigEndian);
+	}
+	uint32_t getSerializedSize() const {
+		return SerializeAdapter<uint16_t>::getSerializedSize(&apid);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+			bool bigEndian) {
+		return SerializeAdapter<uint16_t>::deSerialize(&apid, buffer, size, bigEndian);
+	}
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_APIDMATCHER_H_ */

tmtcpacket/packetmatcher/PacketMatchTree.cpp

@@ -0,0 +1,169 @@
+/*
+ * PacketMatchTree.cpp
+ *
+ *  Created on: 10.03.2015
+ *      Author: baetz
+ */
+
+#include <framework/tmtcpacket/packetmatcher/ApidMatcher.h>
+#include <framework/tmtcpacket/packetmatcher/PacketMatchTree.h>
+#include <framework/tmtcpacket/packetmatcher/ServiceMatcher.h>
+#include <framework/tmtcpacket/packetmatcher/SubserviceMatcher.h>
+
+PacketMatchTree::PacketMatchTree(Node* root) :
+		MatchTree<TmPacketMinimal*>(root, 2), factoryBackend(0, POOL_SIZES,
+				N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::PacketMatchTree(iterator root) :
+		MatchTree<TmPacketMinimal*>(root.element, 2), factoryBackend(0,
+				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::PacketMatchTree() :
+		MatchTree<TmPacketMinimal*>((Node*) NULL, 2), factoryBackend(0,
+				POOL_SIZES, N_ELEMENTS, false, true), factory(&factoryBackend) {
+}
+
+PacketMatchTree::~PacketMatchTree() {
+}
+
+ReturnValue_t PacketMatchTree::addMatch(uint16_t apid, uint8_t type,
+		uint8_t subtype) {
+	//We assume adding APID is always requested.
+	uint8_t expectedHierarchy = 0;
+	if (type != 0) {
+		expectedHierarchy++;
+		if (subtype != 0) {
+			expectedHierarchy++;
+		}
+	}
+	TmPacketMinimal::TmPacketMinimalPointer data;
+	data.data_field.service_type = type;
+	data.data_field.service_subtype = subtype;
+	TmPacketMinimal testPacket((uint8_t*)&data);
+	testPacket.setAPID(apid);
+	uint8_t realHierarchy = 0;
+	iterator lastMatch;
+	bool isInTree = matchesTree(&testPacket, &lastMatch, &realHierarchy);
+	if (isInTree) {
+		//Matches somehow.
+		//TODO: Are we interested in details?
+		return RETURN_OK;
+	}
+	if (expectedHierarchy == realHierarchy) {
+		//Add another element (of correct type) at the OR branch.
+		lastMatch = addElement(OR, realHierarchy, lastMatch, &testPacket);
+		if (lastMatch == this->end()) {
+			return FULL;
+		}
+	} else if (expectedHierarchy > realHierarchy) {
+		//A certain amount of downward structure does not exist. Add first element as OR, rest as AND.
+
+		lastMatch = addElement(OR, realHierarchy, lastMatch, &testPacket);
+		if (lastMatch == end()) {
+			return FULL;
+		}
+		iterator firstOfList = lastMatch;
+		while (lastMatch != end() && realHierarchy < expectedHierarchy) {
+			realHierarchy++;
+			lastMatch = addElement(AND, realHierarchy, lastMatch, &testPacket);
+		}
+		if (lastMatch == end()) {
+			//At least one element could not be inserted. So delete everything.
+			removeElementAndAllChildren(firstOfList);
+			return FULL;
+		}
+	} else {
+		//Might work like that.
+		//Too detailed match, delete the last element and all its children.
+		while (lastMatch.up() != end() && lastMatch.up().left() != lastMatch) {
+			lastMatch = lastMatch.up();
+		}
+		removeElementAndAllChildren(lastMatch);
+	}
+	return RETURN_OK;
+}
+
+ReturnValue_t PacketMatchTree::removeMatch(uint16_t apid, uint8_t type,
+		uint8_t subtype) {
+	//We assume APID is always in request.
+	uint8_t expectedHierarchy = 1;
+	if (type != 0) {
+		expectedHierarchy++;
+		if (subtype != 0) {
+			expectedHierarchy++;
+		}
+	}
+	TmPacketMinimal::TmPacketMinimalPointer data;
+	data.data_field.service_type = type;
+	data.data_field.service_subtype = subtype;
+	TmPacketMinimal testPacket((uint8_t*)&data);
+	testPacket.setAPID(apid);
+	uint8_t realHierarchy = 0;
+	iterator lastMatch;
+	bool isInTree = matchesTree(&testPacket, &lastMatch, &realHierarchy);
+	if (isInTree) {
+		if (expectedHierarchy == realHierarchy) {
+			return removeElementAndReconnectChildren(lastMatch);
+		} else {
+			return TOO_DETAILED_REQUEST;
+		}
+	} else {
+		//TODO: Maybe refine this a bit.
+		return NO_MATCH;
+	}
+}
+
+PacketMatchTree::iterator PacketMatchTree::addElement(bool andBranch,
+		uint8_t level, PacketMatchTree::iterator position,
+		TmPacketMinimal* content) {
+	SerializeableMatcherIF<TmPacketMinimal*>* newContent = NULL;
+	switch (level) {
+	case 0:
+		newContent = factory.generate<ApidMatcher>(content->getAPID());
+		break;
+	case 1:
+		newContent = factory.generate<ServiceMatcher>(content->getService());
+		break;
+	case 2:
+		newContent = factory.generate<SubServiceMatcher>(
+				content->getSubService());
+		break;
+	default:
+		break;
+	}
+	if (newContent == NULL) {
+		return end();
+	}
+	Node* newNode = factory.generate<Node>(newContent);
+	if (newNode == NULL) {
+		return end();
+	}
+	return insert(andBranch, position, newNode);
+}
+
+ReturnValue_t PacketMatchTree::initialize() {
+	return factoryBackend.initialize();
+}
+
+const uint16_t PacketMatchTree::POOL_SIZES[N_POOLS] = { sizeof(ServiceMatcher),
+		sizeof(SubServiceMatcher), sizeof(ApidMatcher),
+		sizeof(PacketMatchTree::Node) };
+//TODO: Rather arbitrary. Adjust!
+const uint16_t PacketMatchTree::N_ELEMENTS[N_POOLS] = { 10, 20, 2, 40 };
+
+ReturnValue_t PacketMatchTree::changeMatch(bool addToMatch, uint16_t apid,
+		uint8_t type, uint8_t subtype) {
+	if (addToMatch) {
+		return addMatch(apid, type, subtype);
+	} else {
+		return removeMatch(apid, type, subtype);
+	}
+}
+
+ReturnValue_t PacketMatchTree::cleanUpElement(iterator position) {
+	//TODO: What if first deletion fails?
+	factory.destroy(position.element->value);
+	return factory.destroy(position.element);
+}

tmtcpacket/packetmatcher/PacketMatchTree.h

@@ -0,0 +1,41 @@
+/*
+ * PacketMatchTree.h
+ *
+ *  Created on: 10.03.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_
+
+#include <framework/container/PlacementFactory.h>
+#include <framework/globalfunctions/matching/MatchTree.h>
+#include <framework/storagemanager/LocalPool.h>
+#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
+
+class PacketMatchTree: public MatchTree<TmPacketMinimal*>, public HasReturnvaluesIF {
+public:
+	PacketMatchTree(Node* root);
+	PacketMatchTree(iterator root);
+	PacketMatchTree();
+	virtual ~PacketMatchTree();
+	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);
+private:
+	static const uint8_t N_POOLS = 4;
+	LocalPool<N_POOLS> factoryBackend;
+	PlacementFactory factory;
+	static const uint16_t POOL_SIZES[N_POOLS];
+	static const uint16_t N_ELEMENTS[N_POOLS];
+	iterator addElement(bool andBranch, uint8_t level, iterator position, TmPacketMinimal* content);
+};
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_PACKETMATCHTREE_H_ */
+

tmtcpacket/packetmatcher/ServiceMatcher.h

@@ -0,0 +1,43 @@
+/*
+ * ServiceMatcher.h
+ *
+ *  Created on: 09.03.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_
+
+#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
+
+class ServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+private:
+	uint8_t service;
+public:
+	ServiceMatcher(uint8_t setService) :
+			service(setService) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getService() == service) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const {
+		return SerializeAdapter<uint8_t>::serialize(&service, buffer, size, max_size, bigEndian);
+	}
+	uint32_t getSerializedSize() const {
+		return SerializeAdapter<uint8_t>::getSerializedSize(&service);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+			bool bigEndian) {
+		return SerializeAdapter<uint8_t>::deSerialize(&service, buffer, size, bigEndian);
+	}
+};
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SERVICEMATCHER_H_ */

tmtcpacket/packetmatcher/SubserviceMatcher.h

@@ -0,0 +1,44 @@
+/*
+ * SubserviceMatcher.h
+ *
+ *  Created on: 09.03.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
+#define FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_
+
+#include <framework/globalfunctions/matching/SerializeableMatcherIF.h>
+#include <framework/serialize/SerializeAdapter.h>
+#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
+
+class SubServiceMatcher: public SerializeableMatcherIF<TmPacketMinimal*> {
+public:
+	SubServiceMatcher(uint8_t subService) :
+			subService(subService) {
+	}
+	bool match(TmPacketMinimal* packet) {
+		if (packet->getSubService() == subService) {
+			return true;
+		} else {
+			return false;
+		}
+	}
+	ReturnValue_t serialize(uint8_t** buffer, uint32_t* size,
+			const uint32_t max_size, bool bigEndian) const {
+		return SerializeAdapter<uint8_t>::serialize(&subService, buffer, size, max_size, bigEndian);
+	}
+	uint32_t getSerializedSize() const {
+		return SerializeAdapter<uint8_t>::getSerializedSize(&subService);
+	}
+	ReturnValue_t deSerialize(const uint8_t** buffer, int32_t* size,
+			bool bigEndian) {
+		return SerializeAdapter<uint8_t>::deSerialize(&subService, buffer, size, bigEndian);
+	}
+private:
+	uint8_t subService;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PACKETMATCHER_SUBSERVICEMATCHER_H_ */

tmtcpacket/pus/TcPacket.cpp

@@ -0,0 +1,74 @@
+/*
+ * TcPacket.cpp
+ *
+ *  Created on: 18.06.2012
+ *      Author: baetz
+ */
+
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tmtcpacket/pus/TcPacket.h>
+#include <string.h>
+template <uint32_t byte_size>
+TcPacket<byte_size>::TcPacket() : TcPacketBase( (uint8_t*)&this->local_data ) {
+	memset( &this->local_data, 0, sizeof(this->local_data) );
+	//Set all constant elements in header according to ECSS E-70-41A (2003)
+	//Primary header:
+	//Set APID to idle packet
+	this->local_data.primary.packet_id_h = 0b00011000;
+	this->setAPID( APID_IDLE_PACKET );
+	//Set Sequence Flags to "stand-alone packet"
+	this->local_data.primary.sequence_control_h = 0b11000000;
+	//Set packet size to size of data field header + CRC
+	this->setPacketDataLength( sizeof(this->local_data.data_field) + CRC_SIZE );
+
+	//Data Field Header:
+	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
+	this->local_data.data_field.version_type_ack = 0b00010000;
+
+}
+
+template <uint32_t byte_size>
+TcPacket<byte_size>::TcPacket( uint16_t new_apid, uint8_t new_ack, uint8_t new_service, uint8_t new_subservice, uint16_t new_sequence_count)  : TcPacketBase( (uint8_t*)&this->local_data ) {
+	memset( &this->local_data, 0, sizeof(this->local_data) );
+	//Set all constant elements in header according to ECSS E-70-41A (2003)
+	//Primary header:
+	//Set APID to idle packet
+	this->local_data.primary.packet_id_h = 0b00011000;
+	this->setAPID( new_apid );
+	//Set Sequence Flags to "stand-alone packet"
+	this->local_data.primary.sequence_control_h = 0b11000000;
+	this->setPacketSequenceCount( new_sequence_count );
+	this->setPacketDataLength( sizeof(this->local_data.data_field) + CRC_SIZE );
+
+	//Data Field Header:
+	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
+	this->local_data.data_field.version_type_ack = 0b00010000;
+	this->local_data.data_field.version_type_ack |= ( new_ack & 0x0F);
+	this->local_data.data_field.service_type = new_service;
+	this->local_data.data_field.service_subtype = new_subservice;
+	this->setErrorControl();
+
+}
+
+template <uint32_t byte_size>
+TcPacket< byte_size >::~TcPacket() {
+}
+
+template <uint32_t byte_size>
+bool TcPacket<byte_size>::addApplicationData( uint8_t* newData, uint32_t amount ) {
+	if ( amount <= ( sizeof(this->local_data.application_data) - CRC_SIZE ) ) {
+		memcpy( this->local_data.application_data, newData, amount );
+		this->setPacketDataLength( amount + sizeof(this->local_data.data_field) + CRC_SIZE  - 1 );
+		this->setErrorControl();
+		return true;
+	} else {
+		return false;
+	}
+}
+
+template class TcPacket<TC_PACKET_MIN_SIZE>;
+template class TcPacket<32>;
+template class TcPacket<64>;
+template class TcPacket<128>;
+template class TcPacket<256>;
+template class TcPacket<1024>;

tmtcpacket/pus/TcPacket.h

@@ -0,0 +1,83 @@
+#ifndef TCPACKET_H_
+#define TCPACKET_H_
+
+#include <framework/tmtcpacket/pus/TcPacketBase.h>
+
+/**
+ * This constant defines the minimum size of a valid PUS Telecommand Packet.
+ */
+#define TC_PACKET_MIN_SIZE (sizeof(CCSDSPrimaryHeader) + sizeof(PUSTcDataFieldHeader) + 2)
+
+/**
+ * The TcPacket class is a representation of a ECSS PUS Telecommand packet.
+
+ * The template parameter is used to instantiate the class with different
+ * maximum Application Data sizes (to avoid wasting stack size).
+ * Telecommand packets are mainly created on ground, which are accessed with
+ * the TcPacketBase class. However, there are occasions when command packets
+ * are created on-board, for example when commanding another PUS compatible
+ * device such as the star trackers.
+ * These packets can be created with the TcPacket class.
+ * A pointer to \c local_data is passed to the \c TcPacketBase parent class,
+ * so the parent's methods are reachable.
+ * @t_param	byte_size	The maximum size of the complete packet (including CRC
+ * 		and headers)
+ * @ingroup tmtcpackets
+ */
+template<uint32_t byte_size>
+class TcPacket : public TcPacketBase {
+private:
+	/**
+	 * This structure defines the data structure of a Telecommand Packet as
+	 * local data.
+	 *
+	 * There's a buffer which corresponds to the Telecommand Application Data
+	 * Field with a maximum size of \c byte_size.
+	 */
+	struct TcPacketData {
+		CCSDSPrimaryHeader primary;
+		PUSTcDataFieldHeader data_field;
+		uint8_t application_data[byte_size - sizeof(CCSDSPrimaryHeader) - sizeof(PUSTcDataFieldHeader)];
+	};
+	/**
+	 * This is the data representation of the class.
+	 */
+	TcPacketData local_data;
+public:
+	/**
+	 * This is the default constructor of the class.
+	 *
+	 * It sets all values to default for a CCSDS Idle Packet (i.e. APID is 2047).
+	 */
+	TcPacket( void );
+	/**
+	 * A constructor which directly sets all relevant header information.
+	 * @param apid			Sets the packet's APID field.
+	 * @param ack			Set's the packet's Ack field,
+	 * 		which specifies number and size of verification packets returned
+	 * 		for this command.
+	 * @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.
+	 */
+	TcPacket( uint16_t apid, uint8_t ack, uint8_t service, uint8_t subservice, uint16_t sequence_count = 0 );
+	/**
+	 * This is the empty default destructor of the class.
+	 */
+	~TcPacket( void );
+	/**
+	 * With this call, application data can be added to the Application Data
+	 * buffer.
+	 * The Error Control Field is updated automatically.
+	 * @param data	The data to add to the Application Data field.
+	 * @param size	The size of the data to add.
+	 * @return	@li	\c true if \c size is smaller than the Application Data
+	 * 		buffer.
+	 * 			@li \c false else.
+	 */
+	bool addApplicationData( uint8_t* data, uint32_t size );
+};
+
+#endif /* TCPACKET_H_ */

tmtcpacket/pus/TcPacketBase.cpp

@@ -0,0 +1,74 @@
+/*
+ * TcPacketBase.cpp
+ *
+ *  Created on: 18.06.2012
+ *      Author: baetz
+ */
+
+#include <framework/globalfunctions/crc_ccitt.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tmtcpacket/pus/TcPacketBase.h>
+
+TcPacketBase::TcPacketBase( const uint8_t* set_data ) : SpacePacketBase( set_data ) {
+	this->tc_data = (TcPacketPointer*)set_data;
+}
+
+TcPacketBase::~TcPacketBase() {
+	//Nothing to do.
+}
+
+uint8_t TcPacketBase::getService() {
+	return this->tc_data->data_field.service_type;
+}
+
+uint8_t TcPacketBase::getSubService() {
+	return this->tc_data->data_field.service_subtype;
+}
+
+uint8_t TcPacketBase::getAcknowledgeFlags() {
+	return this->tc_data->data_field.version_type_ack & 0b00001111;
+}
+
+const uint8_t* TcPacketBase::getApplicationData() const {
+	return &this->tc_data->data;
+}
+
+uint16_t TcPacketBase::getApplicationDataSize() {
+	return this->getPacketDataLength() - sizeof(this->tc_data->data_field)  - CRC_SIZE + 1;
+}
+
+uint16_t TcPacketBase::getErrorControl() {
+	uint16_t size = this->getApplicationDataSize() + CRC_SIZE;
+	uint8_t* p_to_buffer = &this->tc_data->data;
+	return ( p_to_buffer[size - 2] << 8 ) + p_to_buffer[size - 1];
+}
+
+void TcPacketBase::setErrorControl() {
+	uint32_t full_size = this->getFullSize();
+	uint16_t crc = ::Calculate_CRC ( this->getWholeData(), full_size - CRC_SIZE );
+	uint32_t size = this->getApplicationDataSize();
+	(&tc_data->data)[ size ] = ( crc & 0XFF00) >>  8;	// CRCH
+	(&tc_data->data)[ size + 1 ] = ( crc ) & 0X00FF; 		// CRCL
+}
+
+void TcPacketBase::setData(const uint8_t* p_Data) {
+	this->SpacePacketBase::setData( p_Data );
+	this->tc_data = (TcPacketPointer*)p_Data;
+}
+
+uint8_t TcPacketBase::getSecondaryHeaderFlag() {
+	return (this->tc_data->data_field.version_type_ack & 0b10000000) >> 7;
+}
+
+uint8_t TcPacketBase::getPusVersionNumber() {
+	return (this->tc_data->data_field.version_type_ack & 0b01110000) >> 4;
+}
+
+void TcPacketBase::print() {
+	uint8_t * wholeData = this->getWholeData();
+	debug << "TcPacket contains: " << std::endl;
+	for (uint8_t count = 0; count < this->getFullSize(); ++count ) {
+		debug << std::hex << (uint16_t)wholeData[count] << " ";
+	}
+	debug << std::dec << std::endl;
+}

tmtcpacket/pus/TcPacketBase.h

@@ -0,0 +1,170 @@
+#ifndef TCPACKETBASE_H_
+#define TCPACKETBASE_H_
+
+#include <framework/tmtcpacket/SpacePacketBase.h>
+
+/**
+ * This struct defines a byte-wise structured PUS TC Data Field Header.
+ * Any optional fields in the header must be added or removed here.
+ * Currently, the Source Id field is present with one byte.
+ * @ingroup tmtcpackets
+ */
+struct PUSTcDataFieldHeader {
+	uint8_t version_type_ack;
+	uint8_t service_type;
+	uint8_t service_subtype;
+	uint8_t source_id;
+};
+
+/**
+ * This struct defines the data structure of a PUS Telecommand Packet when
+ * accessed via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct TcPacketPointer {
+	CCSDSPrimaryHeader primary;
+	PUSTcDataFieldHeader data_field;
+	uint8_t data;
+};
+
+/**
+ * This class is the basic data handler for any ECSS PUS Telecommand packet.
+ *
+ * In addition to \SpacePacketBase, the class provides methods to handle
+ * the standardized entries of the PUS TC Packet Data Field Header.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * @ingroup tmtcpackets
+ */
+class TcPacketBase : public SpacePacketBase {
+protected:
+	/**
+	 * 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* tc_data;
+public:
+	/**
+	 * With this constant for the acknowledge field responses on all levels are expected.
+	 */
+	static const uint8_t ACK_ALL = 0b1111;
+	/**
+	 * With this constant for the acknowledge field a response on acceptance is expected.
+	 */
+	static const uint8_t ACK_ACCEPTANCE = 0b0001;
+	/**
+	 * With this constant for the acknowledge field a response on start of execution is expected.
+	 */
+	static const uint8_t ACK_START = 0b0010;
+	/**
+	 * With this constant for the acknowledge field responses on execution steps are expected.
+	 */
+	static const uint8_t ACK_STEP = 0b0100;
+	/**
+	 * With this constant for the acknowledge field a response on completion is expected.
+	 */
+	static const uint8_t ACK_COMPLETION = 0b1000;
+	/**
+	 * With this constant for the acknowledge field no responses are expected.
+	 */
+	static const uint8_t ACK_NONE = 0b000;
+	/**
+	 * 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 set_address	The position where the packet data lies.
+	 */
+	TcPacketBase( const uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TcPacketBase();
+	/**
+	 * This command returns the CCSDS Secondary Header Flag.
+	 * It shall always be zero for PUS Packets. This is the
+	 * highest bit of the first byte of the Data Field Header.
+	 * @return	the CCSDS Secondary Header Flag
+	 */
+	uint8_t getSecondaryHeaderFlag();
+	/**
+	 * 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
+	 */
+	uint8_t getPusVersionNumber();
+	/**
+	 * 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.
+	 *
+	 * It is packed in a uint8_t variable.
+	 * @return	The packet's PUS Ack field.
+	 */
+	uint8_t getAcknowledgeFlags();
+	/**
+	 * 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();
+	/**
+	 * 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.
+	 */
+	const uint8_t* getApplicationData() const;
+	/**
+	 * 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)
+	 */
+	uint16_t getApplicationDataSize();
+	/**
+	 * 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
+	 */
+	uint16_t getErrorControl();
+	/**
+	 * With this method, the Error Control Field is updated to match the
+	 * current content of the packet.
+	 */
+	void setErrorControl();
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 *
+	 * This call overwrites the parent's setData method to set both its
+	 * \c tc_data pointer and the parent's \c data pointer.
+	 *
+	 * @param p_data	A pointer to another PUS Telecommand Packet.
+	 */
+	void setData( const uint8_t* p_data );
+	/**
+	 * This is a debugging helper method that prints the whole packet content
+	 * to the screen.
+	 */
+	void print();
+};
+
+
+#endif /* TCPACKETBASE_H_ */

tmtcpacket/pus/TcPacketStored.cpp

@@ -0,0 +1,104 @@
+
+/*
+ * TcPacketStored.cpp
+ *
+ *  Created on: 20.11.2012
+ *      Author: baetz
+ */
+
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tmtcpacket/pus/TcPacket.h>
+#include <framework/tmtcpacket/pus/TcPacketStored.h>
+#include <string.h>
+
+TcPacketStored::TcPacketStored( store_address_t setAddress) : TcPacketBase(NULL), storeAddress(setAddress) {
+	this->setStoreAddress( this->storeAddress );
+}
+
+TcPacketStored::TcPacketStored( uint16_t apid, uint8_t ack, uint8_t service, uint8_t subservice,
+		uint8_t sequence_count, const uint8_t* data, uint32_t size) : TcPacketBase(NULL) {
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if ( this->checkAndSetStore() ) {
+		TcPacket<TC_PACKET_MIN_SIZE> temp_packet( apid, ack, service, subservice, sequence_count);
+		uint8_t* p_data = NULL;
+		ReturnValue_t returnValue = this->store->getFreeElement( &this->storeAddress, (TC_PACKET_MIN_SIZE + size), &p_data );
+		if ( returnValue == this->store->RETURN_OK ) {
+			memcpy(p_data, temp_packet.getWholeData(), temp_packet.getFullSize() );
+			this->setData( p_data );
+			memcpy( &tc_data->data, data, size );
+			this->setPacketDataLength( size + sizeof(PUSTcDataFieldHeader) + CRC_SIZE  - 1 );
+			this->setErrorControl();
+		}
+	}
+}
+
+TcPacketStored::TcPacketStored() : TcPacketBase(NULL) {
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	this->checkAndSetStore();
+
+}
+
+//TODO: return code?
+void TcPacketStored::deletePacket() {
+	this->store->deleteData( this->storeAddress );
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	this->setData( NULL );
+}
+
+bool TcPacketStored::checkAndSetStore() {
+	if (this->store == NULL) {
+		this->store = objectManager->get<StorageManagerIF>( objects::TC_STORE );
+		if ( this->store == NULL ) {
+			error << "TcPacketStored::TcPacketStored: TC Store not found!" << std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+void TcPacketStored::setStoreAddress(store_address_t setAddress) {
+	this->storeAddress = setAddress;
+	const uint8_t* temp_data = NULL;
+	uint32_t temp_size;
+	ReturnValue_t status = StorageManagerIF::RETURN_FAILED;
+	if ( this->checkAndSetStore() ) {
+		status = this->store->getData(this->storeAddress, &temp_data, &temp_size );
+	}
+	if (status == StorageManagerIF::RETURN_OK) {
+		this->setData(temp_data);
+	} else {
+		this->setData(NULL);
+		this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	}
+}
+
+store_address_t TcPacketStored::getStoreAddress() {
+	return this->storeAddress;
+}
+
+bool TcPacketStored::isSizeCorrect() {
+	const uint8_t* temp_data = NULL;
+	uint32_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;
+}
+
+StorageManagerIF* TcPacketStored::store = NULL;
+
+TcPacketStored::TcPacketStored(const uint8_t* data, uint32_t size) : TcPacketBase(data) {
+	if (getFullSize() != size) {
+		return;
+	}
+	if ( this->checkAndSetStore() ) {
+		ReturnValue_t status = store->addData(&storeAddress, data, size);
+		if (status != HasReturnvaluesIF::RETURN_OK) {
+			this->setData(NULL);
+		}
+	}
+}

tmtcpacket/pus/TcPacketStored.h

@@ -0,0 +1,104 @@
+#ifndef TCPACKETSTORED_H_
+#define TCPACKETSTORED_H_
+
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/tmtcpacket/pus/TcPacketBase.h>
+
+/**
+ *	This class generates a ECSS PUS Telecommand 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 TcPacketStored : public TcPacketBase {
+private:
+	/**
+	 * 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.
+	 */
+	bool checkAndSetStore();
+public:
+	/**
+	 * This is a default constructor which does not set the data pointer.
+	 * However, it does try to set the packet store.
+	 */
+	TcPacketStored();
+	/**
+	 * With this constructor, the class instance is linked to an existing
+	 * packet in the packet store.
+	 * The packet content is neither checked nor changed with this call. If
+	 * the packet could not be found, the data pointer is set to NULL.
+	 */
+	TcPacketStored( store_address_t setAddress );
+	/**
+	 * 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 ack			Set's the packet's Ack field,
+	 * 		which specifies number and size of verification packets returned
+	 * 		for this command.
+	 * @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.
+	 */
+	TcPacketStored( uint16_t apid, uint8_t ack, uint8_t service, uint8_t subservice, uint8_t sequence_count = 0, const uint8_t* data = NULL, uint32_t size = 0 );
+	/**
+	 * 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.
+	 */
+	TcPacketStored( const uint8_t* data, uint32_t size);
+	/**
+	 * 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 );
+	/**
+	 * 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.
+	 */
+	bool isSizeCorrect();
+};
+
+
+#endif /* TCPACKETSTORED_H_ */

tmtcpacket/pus/TmPacket.cpp

@@ -0,0 +1,80 @@
+/*
+ * TmPacket.cpp
+ *
+ *  Created on: 18.06.2012
+ *      Author: baetz
+ */
+
+#include <framework/tmtcpacket/pus/TmPacket.h>
+#include <string.h>
+template <uint32_t byte_size>
+TmPacket<byte_size>::TmPacket() : TmPacketBase( (uint8_t*)&this->local_data ) {
+	memset( &this->local_data, 0, sizeof(this->local_data) );
+	//Set all constant elements in header according to ECSS E-70-41A (2003)
+	//Primary header:
+	//Set APID to idle packet
+	local_data.primary.packet_id_h = 0b00001000;
+	setAPID( APID_IDLE_PACKET );
+	//Set Sequence Flags to "stand-alone packet"
+	local_data.primary.sequence_control_h = 0b11000000;
+	//Set packet size to size of data field header + CRC
+	setPacketDataLength( sizeof(this->local_data.data_field) + CRC_SIZE );
+	if (checkAndSetStamper()) {
+		timeStamper->addTimeStamp(local_data.data_field.time, sizeof(local_data.data_field.time));
+	}
+	//Data Field Header:
+	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
+	this->local_data.data_field.version_type_ack = 0b00010000;
+
+}
+
+template <uint32_t byte_size>
+TmPacket<byte_size>::TmPacket( uint16_t new_apid, uint8_t new_service, uint8_t new_subservice, uint8_t new_packet_counter )  : TmPacketBase( (uint8_t*)&this->local_data ) {
+	memset( &this->local_data, 0, sizeof(this->local_data) );
+	//Set all constant elements in header according to ECSS E-70-41A (2003)
+	//Primary header:
+	//Set APID to idle packet
+	this->local_data.primary.packet_id_h = 0b00001000;
+	this->setAPID( new_apid );
+	//Set Sequence Flags to "stand-alone packet"
+	this->local_data.primary.sequence_control_h = 0b11000000;
+	//Set Data Length to minimum size (Data Field Header + CRC size)
+	this->setPacketDataLength( sizeof(this->local_data.data_field) + CRC_SIZE );
+
+	//Data Field Header:
+	//Set CCSDS_secondary_header_flag to 0, version number to 001 and ack to 0000
+	this->local_data.data_field.version_type_ack = 0b00010000;
+	this->local_data.data_field.service_type = new_service;
+	this->local_data.data_field.service_subtype = new_subservice;
+	this->local_data.data_field.subcounter = new_packet_counter;
+
+	if (checkAndSetStamper()) {
+		timeStamper->addTimeStamp(local_data.data_field.time, sizeof(local_data.data_field.time));
+	}
+
+//	this->local_data.data_field.destination = new_destination;
+	this->setErrorControl();
+}
+
+template <uint32_t byte_size>
+TmPacket< byte_size >::~TmPacket() {
+}
+
+template <uint32_t byte_size>
+bool TmPacket<byte_size>::addSourceData( uint8_t* newData, uint32_t amount ) {
+	if ( amount <= ( sizeof(this->local_data.source_data) - CRC_SIZE ) ) {
+		memcpy( this->local_data.source_data, newData, amount );
+		this->setPacketDataLength( amount + sizeof(this->local_data.data_field) + CRC_SIZE  - 1 );
+		this->setErrorControl();
+		return true;
+	} else {
+		return false;
+	}
+}
+
+template class TmPacket<TmPacketBase::TM_PACKET_MIN_SIZE>;
+template class TmPacket<64>;
+template class TmPacket<128>;
+template class TmPacket<256>;
+template class TmPacket<512>;
+template class TmPacket<1024>;

tmtcpacket/pus/TmPacket.h

@@ -0,0 +1,72 @@
+#ifndef TMPACKET_H_
+#define TMPACKET_H_
+
+#include <framework/tmtcpacket/pus/TmPacketBase.h>
+
+/**
+ * The TmPacket class is a representation of a ECSS PUS Telemetry packet.
+
+ * The template parameter is used to instantiate the class with different
+ * maximum Application Data sizes (to avoid wasting stack size). Almost every
+ * on-board service is a source of telemetry packets. These packets are created
+ * with the TmPacket class, which is instantiated similar to the TcPacket
+ * class.
+ * A pointer to \c local_data is passed to the \c TmPacketBase parent class,
+ * so the parent's methods are reachable.
+ * @t_param	byte_size	The maximum size of the complete packet (including CRC
+ * 		and headers)
+ * @ingroup tmtcpackets
+ */
+template<uint32_t byte_size>
+class TmPacket : public TmPacketBase {
+public:
+	/**
+	 * This is the default constructor of the class.
+	 *
+	 * It sets all values to default for a CCSDS Idle Packet (i.e. APID is 2047).
+	 */
+	TmPacket( void );
+	/**
+	 * A constructor which directly sets all relevant header information.
+	 * @param apid			Sets the packet's APID field.
+	 * @param service		Sets the packet's Service ID field.
+	 * 		This specifies the source service.
+	 * @param subservice	Sets the packet's Service Subtype field.
+	 * 		This specifies the source sub-service.
+	 * @param packet_counter	Sets the Packet counter field of this packet.
+	 */
+	TmPacket( uint16_t apid, uint8_t service, uint8_t subservice, uint8_t packet_counter = 0 );
+	/**
+	 * This is the empty default destructor of the class.
+	 */
+	~TmPacket( void );
+	/**
+	 * With this call, application data can be added to the Source Data
+	 * buffer.
+	 * The Error Control Field is updated automatically.
+	 * @param data	The data to add to the Source Data field.
+	 * @param size	The size of the data to add.
+	 * @return	@li	\c true if \c size is smaller than the Source Data buffer.
+	 * 			@li \c false else.
+	 */
+	bool addSourceData( uint8_t*, uint32_t );
+private:
+	/**
+	 * This structure defines the data structure of a Telemetry Packet as
+	 * local data.
+	 *
+	 * There's a buffer which corresponds to the Telemetry Source Data Field
+	 * with a maximum size of \c byte_size.
+	 */
+	struct TmPacketData {
+		CCSDSPrimaryHeader primary;
+		PUSTmDataFieldHeader data_field;
+		uint8_t source_data[byte_size - sizeof(CCSDSPrimaryHeader) - sizeof(PUSTmDataFieldHeader)];
+	};
+	/**
+	 * This is the data representation of the class.
+	 */
+	TmPacketData local_data;
+};
+
+#endif /* TMPACKET_H_ */

tmtcpacket/pus/TmPacketBase.cpp

@@ -0,0 +1,78 @@
+/*
+ * TmPacketBase.cpp
+ *
+ *  Created on: 18.06.2012
+ *      Author: baetz
+ */
+
+#include <framework/globalfunctions/crc_ccitt.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tmtcpacket/pus/TmPacketBase.h>
+
+TmPacketBase::TmPacketBase( uint8_t* set_data ) : SpacePacketBase( set_data ) {
+	this->tm_data = (TmPacketPointer*)set_data;
+}
+
+TmPacketBase::~TmPacketBase() {
+	//Nothing to do.
+}
+
+uint8_t TmPacketBase::getService() {
+	return this->tm_data->data_field.service_type;
+}
+
+uint8_t TmPacketBase::getSubService() {
+	return this->tm_data->data_field.service_subtype;
+}
+
+uint8_t* TmPacketBase::getSourceData() {
+	return &this->tm_data->data;
+}
+
+uint16_t TmPacketBase::getSourceDataSize() {
+	return this->getPacketDataLength() - sizeof(this->tm_data->data_field) - CRC_SIZE  + 1;
+}
+
+uint16_t TmPacketBase::getErrorControl() {
+	uint32_t size = this->getSourceDataSize() + CRC_SIZE;
+	uint8_t* p_to_buffer = &this->tm_data->data;
+	return ( p_to_buffer[size - 2] << 8 ) + p_to_buffer[size - 1];
+}
+
+
+void TmPacketBase::setErrorControl() {
+	uint32_t full_size = this->getFullSize();
+	uint16_t crc = ::Calculate_CRC ( this->getWholeData(), full_size - CRC_SIZE );
+	uint32_t size = this->getSourceDataSize();
+	this->getSourceData()[ size ] = ( crc & 0XFF00) >>  8;	// CRCH
+	this->getSourceData()[ size + 1 ] = ( crc ) & 0X00FF; 		// CRCL
+}
+
+void TmPacketBase::setData(const uint8_t* p_Data) {
+	this->SpacePacketBase::setData( p_Data );
+	this->tm_data = (TmPacketPointer*)p_Data;
+}
+
+void TmPacketBase::print() {
+	/*uint8_t * wholeData = this->getWholeData();
+	debug << "TmPacket contains: " << std::endl;
+	for (uint8_t count = 0; count < this->getFullSize(); ++count ) {
+		debug << std::hex << (uint16_t)wholeData[count] << " ";
+	}
+	debug << std::dec << std::endl;*/
+}
+
+bool TmPacketBase::checkAndSetStamper() {
+	if (timeStamper == NULL) {
+		//TODO: Adjust name?
+		timeStamper = objectManager->get<TimeStamperIF>( objects::TIME_MANAGER );
+		if ( timeStamper == NULL ) {
+			error << "TmPacketBase::checkAndSetStamper: Stamper not found!" << std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+TimeStamperIF* TmPacketBase::timeStamper = NULL;

tmtcpacket/pus/TmPacketBase.h

@@ -0,0 +1,143 @@
+#ifndef TMPACKETBASE_H_
+#define TMPACKETBASE_H_
+
+#include <framework/timemanager/TimeStamperIF.h>
+#include <framework/tmtcpacket/SpacePacketBase.h>
+
+/**
+ * This struct defines a byte-wise structured PUS TM Data Field Header.
+ * Any optional fields in the header must be added or removed here.
+ * Currently, no Destination field is present, but an eigth-byte representation
+ * for a time tag [TBD].
+ * @ingroup tmtcpackets
+ */
+struct PUSTmDataFieldHeader {
+	uint8_t version_type_ack;
+	uint8_t service_type;
+	uint8_t service_subtype;
+	uint8_t subcounter;
+//	uint8_t destination;
+	uint8_t time[TimeStamperIF::MISSION_TIMESTAMP_SIZE];
+};
+
+/**
+ * This struct defines the data structure of a PUS Telecommand Packet when
+ * accessed via a pointer.
+ * @ingroup tmtcpackets
+ */
+struct TmPacketPointer {
+	CCSDSPrimaryHeader primary;
+	PUSTmDataFieldHeader data_field;
+	uint8_t data;
+};
+
+//TODO: add getTime, getSubcounter, getDestionation (if required)
+
+/**
+ * This class is the basic data handler for any ECSS PUS Telemetry packet.
+ *
+ * In addition to \SpacePacketBase, the class provides methods to handle
+ * the standardized entries of the PUS TM Packet Data Field Header.
+ * It does not contain the packet data itself but a pointer to the
+ * data must be set on instantiation. An invalid pointer may cause
+ * damage, as no getter method checks data validity. Anyway, a NULL
+ * check can be performed by making use of the getWholeData method.
+ * @ingroup tmtcpackets
+ */
+class TmPacketBase : public SpacePacketBase {
+public:
+	/**
+	 * 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 set_address	The position where the packet data lies.
+	 */
+	TmPacketBase( uint8_t* set_data );
+	/**
+	 * This is the empty default destructor.
+	 */
+	virtual ~TmPacketBase();
+	/**
+	 * 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();
+	/**
+	 * This is a getter for a pointer to the packet's Source data.
+	 *
+	 * These are the bytes that follow after the Data Field Header. They form
+	 * the packet's source data.
+	 * @return	A pointer to the PUS Source Data.
+	 */
+	uint8_t* getSourceData();
+	/**
+	 * This method calculates the size of the PUS Source 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 Source Data (without Error Control field)
+	 */
+	uint16_t getSourceDataSize();
+	/**
+	 * This getter returns the Error Control Field of the packet.
+	 *
+	 * The field is placed after any possible Source Data. If no
+	 * Source Data is present there's still an Error Control field. It is
+	 * supposed to be a 16bit-CRC.
+	 * @return	The PUS Error Control
+	 */
+	uint16_t getErrorControl();
+	/**
+	 * With this method, the Error Control Field is updated to match the
+	 * current content of the packet.
+	 */
+	void setErrorControl();
+	/**
+	 * With this method, the packet data pointer can be redirected to another
+	 * location.
+	 *
+	 * This call overwrites the parent's setData method to set both its
+	 * \c tc_data pointer and the parent's \c data pointer.
+	 *
+	 * @param p_data	A pointer to another PUS Telemetry Packet.
+	 */
+	void setData( const uint8_t* p_Data );
+	/**
+	 * This is a debugging helper method that prints the whole packet content
+	 * to the screen.
+	 */
+	void print();
+	/**
+	 * 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);
+	static const uint32_t MISSION_TM_PACKET_MAX_SIZE = 2048; //!< Maximum size of a TM Packet in this mission.
+protected:
+	/**
+	 * 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.
+	 */
+	TmPacketPointer* tm_data;
+	/**
+	 * The timeStamper is responsible for adding a timestamp to the packet.
+	 * It is initialized lazy.
+	 */
+	static TimeStamperIF* timeStamper;
+	/**
+	 * Checks if a time stamper is available and tries to set it if not.
+	 * @return Returns false if setting failed.
+	 */
+	bool checkAndSetStamper();
+};
+
+
+#endif /* TMPACKETBASE_H_ */

tmtcpacket/pus/TmPacketMinimal.cpp

@@ -0,0 +1,21 @@
+
+#include <framework/tmtcpacket/pus/TmPacketMinimal.h>
+
+TmPacketMinimal::TmPacketMinimal(const uint8_t* set_data) : SpacePacketBase( 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;
+}

tmtcpacket/pus/TmPacketMinimal.h

@@ -0,0 +1,80 @@
+/*
+ * TmPacketMinimal.h
+ *
+ *  Created on: 09.03.2015
+ *      Author: baetz
+ */
+
+#ifndef FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
+#define FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_
+
+
+#include <framework/tmtcpacket/SpacePacketBase.h>
+
+/**
+ * This is a minimal version of a PUS TmPacket without any variable field, or,
+ * in other words with Service Type, Subtype and subcounter only.
+ * This is required for handling TM packets with different APIDs with different
+ * secondary headers.
+ */
+class TmPacketMinimal : public SpacePacketBase {
+public:
+	/**
+	 * 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 set_address	The position where the packet data lies.
+	 */
+	TmPacketMinimal( const uint8_t* set_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;
+	};
+
+	/**
+	 * This struct defines the data structure of a PUS Telecommand Packet when
+	 * accessed via a pointer.
+	 * @ingroup tmtcpackets
+	 */
+	struct TmPacketMinimalPointer {
+		CCSDSPrimaryHeader primary;
+		PUSTmMinimalHeader data_field;
+		uint8_t rest;
+	};
+	static const uint16_t MINIMUM_SIZE = sizeof(TmPacketMinimalPointer) -1;
+protected:
+	/**
+	 * 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.
+	 */
+	TmPacketMinimalPointer* tm_data;
+};
+
+
+
+#endif /* FRAMEWORK_TMTCPACKET_PUS_TMPACKETMINIMAL_H_ */

tmtcpacket/pus/TmPacketStored.cpp

@@ -0,0 +1,105 @@
+/*
+ * TmPacketStored.cpp
+ *
+ *  Created on: 19.11.2012
+ *      Author: baetz
+ */
+
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tmtcpacket/pus/TmPacket.h>
+#include <framework/tmtcpacket/pus/TmPacketStored.h>
+#include <string.h>
+
+TmPacketStored::TmPacketStored( store_address_t setAddress  ) : TmPacketBase(NULL), storeAddress(setAddress) {
+	this->setStoreAddress( this->storeAddress );
+}
+
+TmPacketStored::TmPacketStored( uint16_t apid, uint8_t service,
+		uint8_t subservice, uint8_t packet_counter, const uint8_t* data, uint32_t size,const uint8_t* headerData, uint32_t headerSize) : TmPacketBase(NULL) {
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if ( this->checkAndSetStore() ) {
+		TmPacket<TmPacketBase::TM_PACKET_MIN_SIZE> temp_packet( apid, service, subservice, packet_counter );
+		uint8_t* p_data = NULL;
+		ReturnValue_t returnValue = this->store->getFreeElement( &this->storeAddress, (TmPacketBase::TM_PACKET_MIN_SIZE + size + headerSize), &p_data );
+		if ( returnValue == this->store->RETURN_OK ) {
+			memcpy(p_data, temp_packet.getWholeData(), temp_packet.getFullSize() );
+			this->setData( p_data );
+			memcpy( this->getSourceData(), headerData, headerSize );
+			memcpy( this->getSourceData() + headerSize, data, size );
+			this->setPacketDataLength( size + headerSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE  - 1 );
+			this->setErrorControl();
+		}
+	}
+}
+
+TmPacketStored::TmPacketStored(uint16_t apid, uint8_t service,
+		uint8_t subservice, uint8_t packet_counter, SerializeIF* content,
+		SerializeIF* header) : TmPacketBase(NULL) {
+	storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	if ( checkAndSetStore() ) {
+		TmPacket<TmPacketBase::TM_PACKET_MIN_SIZE> temp_packet( apid, service, subservice, packet_counter );
+		uint32_t sourceDataSize = 0;
+		if (content != NULL) {
+			sourceDataSize += content->getSerializedSize();
+		}
+		if (header != NULL) {
+			sourceDataSize += header->getSerializedSize();
+		}
+		uint8_t* p_data = NULL;
+		ReturnValue_t returnValue = this->store->getFreeElement( &this->storeAddress, (TmPacketBase::TM_PACKET_MIN_SIZE + sourceDataSize), &p_data );
+		if ( returnValue == store->RETURN_OK ) {
+			memcpy(p_data, temp_packet.getWholeData(), temp_packet.getFullSize() );
+			this->setData( p_data );
+			uint8_t* putDataHere = getSourceData();
+			uint32_t size = 0;
+			if (header != NULL) {
+				header->serialize(&putDataHere, &size, sourceDataSize, true);
+			}
+			if (content != NULL) {
+				content->serialize(&putDataHere, &size, sourceDataSize, true);
+			}
+			this->setPacketDataLength( sourceDataSize + sizeof(PUSTmDataFieldHeader) + CRC_SIZE  - 1 );
+			this->setErrorControl();
+		}
+	}
+}
+
+store_address_t TmPacketStored::getStoreAddress() {
+	return this->storeAddress;
+}
+
+void TmPacketStored::deletePacket() {
+	this->store->deleteData( this->storeAddress );
+	this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	this->setData( NULL );
+}
+
+void TmPacketStored::setStoreAddress(store_address_t setAddress) {
+	this->storeAddress = setAddress;
+	const uint8_t* temp_data = NULL;
+	uint32_t temp_size;
+	if (!checkAndSetStore()) {
+		return;
+	}
+	ReturnValue_t status = this->store->getData(this->storeAddress, &temp_data, &temp_size );
+	if (status == StorageManagerIF::RETURN_OK) {
+		this->setData(temp_data);
+	} else {
+		this->setData(NULL);
+		this->storeAddress.raw = StorageManagerIF::INVALID_ADDRESS;
+	}
+}
+
+bool TmPacketStored::checkAndSetStore() {
+	if (this->store == NULL) {
+		this->store = objectManager->get<StorageManagerIF>( objects::TM_STORE );
+		if ( this->store == NULL ) {
+			error << "TmPacketStored::TmPacketStored: TM Store not found!" << std::endl;
+			return false;
+		}
+	}
+	return true;
+}
+
+StorageManagerIF* TmPacketStored::store = NULL;

tmtcpacket/pus/TmPacketStored.h

@@ -0,0 +1,87 @@
+#ifndef TMPACKETSTORED_H_
+#define TMPACKETSTORED_H_
+
+#include <framework/serialize/SerializeIF.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/tmtcpacket/pus/TmPacketBase.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 TmPacketStored : public TmPacketBase {
+private:
+	/**
+	 * 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;
+	/**
+	 * 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();
+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 );
+	/**
+	 * With this constructor, new space is allocated in the packet store and
+	 * a new PUS Telemetry Packet is created there.
+	 * Packet Application Data passed in data is copied into the packet. The Application data is
+	 * passed in two parts, first a header, then a data field. This allows building a Telemetry
+	 * Packet from two separate data sources.
+	 * @param apid			Sets the packet's APID field.
+	 * @param service		Sets the packet's Service ID field.
+	 * 		This specifies the source service.
+	 * @param subservice	Sets the packet's Service Subtype field.
+	 * 		This specifies the source sub-service.
+	 * @param packet_counter	Sets the Packet counter field of this packet
+	 * @param data			The payload data to be copied to the Application Data Field
+	 * @param size			The amount of data to be copied.
+	 * @param headerData 	The header Data of the Application field; will be copied in front of data
+	 * @param headerSize	The size of the headerDataF
+	 */
+	TmPacketStored( uint16_t apid, uint8_t service,	uint8_t subservice, uint8_t packet_counter = 0, const uint8_t* data = NULL, uint32_t size = 0, const uint8_t* headerData = NULL, uint32_t headerSize = 0);
+	/**
+	 * 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, uint8_t packet_counter, SerializeIF* content, SerializeIF* header = NULL);
+	/**
+	 * 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 );
+};
+
+
+#endif /* TMPACKETSTORED_H_ */