Today's the day. Renamed platform to framework.

tcdistribution/CCSDSDistributor.cpp

@@ -0,0 +1,81 @@
+/*
+ * CCSDSDistributor.cpp
+ *
+ *  Created on: 18.06.2012
+ *      Author: baetz
+ */
+
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tcdistribution/CCSDSDistributor.h>
+#include <framework/tmtcpacket/SpacePacketBase.h>
+
+CCSDSDistributor::CCSDSDistributor( uint16_t set_default_apid ) :
+		TcDistributor( objects::CCSDS_PACKET_DISTRIBUTOR ), default_apid( set_default_apid ), tcStore(NULL) {
+}
+
+CCSDSDistributor::~CCSDSDistributor() {
+
+}
+
+iterator_t CCSDSDistributor::selectDestination() {
+//	debug << "CCSDSDistributor::selectDestination received: " << this->currentMessage.getStorageId().pool_index << ", " << this->currentMessage.getStorageId().packet_index << std::endl;
+	const uint8_t* p_packet = NULL;
+	uint32_t size = 0;
+	this->tcStore->getData( this->currentMessage.getStorageId(), &p_packet, &size );
+	SpacePacketBase current_packet( p_packet );
+//	info << "CCSDSDistributor::selectDestination has packet with APID " << std::hex << current_packet.getAPID() << std::dec << std::endl;
+	iterator_t position = this->queueMap.find( current_packet.getAPID() );
+	if ( position != this->queueMap.end() ) {
+		return position;
+	} else {
+		//The APID was not found. Forward packet to main SW-APID anyway to create acceptance failure report.
+		return this->queueMap.find( this->default_apid );
+	}
+
+}
+
+MessageQueueId_t CCSDSDistributor::getRequestQueue() {
+	return this->tcQueue.getId();
+}
+
+ReturnValue_t CCSDSDistributor::registerApplication(
+		AcceptsTelecommandsIF* application) {
+	ReturnValue_t returnValue = RETURN_OK;
+	bool errorCode = true;
+	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( application->getIdentifier(), application->getRequestQueue() ) ).second;
+	if(  errorCode == false ) {
+		returnValue = RETURN_FAILED;
+	}
+	return returnValue;
+}
+
+ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid,
+		MessageQueueId_t id) {
+	ReturnValue_t returnValue = RETURN_OK;
+	bool errorCode = true;
+	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( apid, id ) ).second;
+	if(  errorCode == false ) {
+		returnValue = RETURN_FAILED;
+	}
+	return returnValue;
+
+}
+
+uint16_t CCSDSDistributor::getIdentifier() {
+	return 0;
+}
+
+ReturnValue_t CCSDSDistributor::initialize() {
+	ReturnValue_t status = this->TcDistributor::initialize();
+	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
+	if (this->tcStore == NULL) status = RETURN_FAILED;
+	return status;
+}
+
+ReturnValue_t CCSDSDistributor::callbackAfterSending(
+		ReturnValue_t queueStatus) {
+	if (queueStatus != RETURN_OK) {
+		tcStore->deleteData(currentMessage.getStorageId());
+	}
+	return RETURN_OK;
+}

tcdistribution/CCSDSDistributor.h

@@ -0,0 +1,65 @@
+/*
+ * CCSDSDistributor.h
+ *
+ *  Created on: 18.06.2012
+ *      Author: baetz
+ */
+
+#ifndef CCSDSDISTRIBUTOR_H_
+#define CCSDSDISTRIBUTOR_H_
+
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/tcdistribution/CCSDSDistributorIF.h>
+#include <framework/tcdistribution/TcDistributor.h>
+#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
+/**
+ * An instantiation of the CCSDSDistributorIF.
+ * It receives Space Packets, and selects a destination depending on the APID of the telecommands.
+ * The Secondary Header (with Service/Subservice) is ignored.
+ * \ingroup tc_distribution
+ */
+class CCSDSDistributor : public TcDistributor, public CCSDSDistributorIF, public AcceptsTelecommandsIF {
+protected:
+	/**
+	 * This implementation checks if an Application with fitting APID has registered and forwards the
+	 * packet to the according message queue.
+	 * If the packet is not found, it returns the queue to \c default_apid, where a Acceptance Failure
+	 * message should be generated.
+	 * @return Iterator to map entry of found APID or iterator to default APID.
+	 */
+	iterator_t selectDestination();
+	/**
+	 * The default APID, where packets with unknown APID are sent to.
+	 */
+	uint16_t default_apid;
+	/**
+	 * A reference to the TC storage must be maintained, as this class handles pure Space Packets and there
+	 * exists no SpacePacketStored class.
+	 */
+	StorageManagerIF* tcStore;
+	/**
+	 * The callback here handles the generation of acceptance success/failure messages.
+	 */
+	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+public:
+	/**
+	 * The constructor sets the default APID and calls the TcDistributor ctor with a certain object id.
+	 * \c tcStore is set in the \c initialize method.
+	 * @param set_default_apid The default APID, where packets with unknown destination are sent to.
+	 */
+	CCSDSDistributor( uint16_t set_default_apid = 0x35 );
+	/**
+	 * The destructor is empty.
+	 */
+	~CCSDSDistributor();
+	MessageQueueId_t getRequestQueue();
+	ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id );
+	ReturnValue_t registerApplication( AcceptsTelecommandsIF* application );
+	uint16_t getIdentifier();
+	ReturnValue_t initialize();
+};
+
+
+
+#endif /* CCSDSDISTRIBUTOR_H_ */

tcdistribution/CCSDSDistributorIF.h

@@ -0,0 +1,47 @@
+/*
+ * CCSDSDistributorIF.h
+ *
+ *  Created on: 21.11.2012
+ *      Author: baetz
+ */
+
+#ifndef CCSDSDISTRIBUTORIF_H_
+#define CCSDSDISTRIBUTORIF_H_
+
+#include <framework/ipc/MessageQueue.h>
+#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
+/**
+ * This is the Interface to a CCSDS Distributor.
+ * On a CCSDS Distributor, Applications (in terms of CCSDS) may register themselves,
+ * either by passing a pointer to themselves (and implementing the CCSDSApplicationIF,
+ * or by explicitly passing an APID and a MessageQueueId to route the TC's to.
+ * \ingroup tc_distribution
+ */
+class CCSDSDistributorIF {
+public:
+	/**
+	 * With this call, a class implementing the CCSDSApplicationIF can register at the
+	 * distributor.
+	 * @param application A pointer to the Application to register.
+	 * @return	- \c RETURN_OK on success,
+	 * 			- \c RETURN_FAILED on failure.
+	 */
+	virtual ReturnValue_t registerApplication( AcceptsTelecommandsIF* application ) = 0;
+	/**
+	 * With this call, other Applications can register to the CCSDS distributor.
+	 * This is done by passing an APID and a MessageQueueId to the method.
+	 * @param apid	The APID to register.
+	 * @param id	The MessageQueueId of the message queue to send the TC Packets to.
+	 * @return	- \c RETURN_OK on success,
+	 * 			- \c RETURN_FAILED on failure.
+	 */
+	virtual ReturnValue_t registerApplication( uint16_t apid, MessageQueueId_t id ) = 0;
+	/**
+	 * The empty virtual destructor.
+	 */
+	virtual ~CCSDSDistributorIF() {
+	}
+};
+
+
+#endif /* CCSDSDISTRIBUTORIF_H_ */

tcdistribution/Makefile

@@ -0,0 +1,23 @@
+#!/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)/TcDistributor.o\
+			$(BUILDDIR)/CCSDSDistributor.o
+
+all: $(OBJ)
+	 		
+$(BUILDDIR)/%.o: %.cpp %.h
+	$(CPP) $(CFLAGS) $(DEFINES) $(CCOPT) ${INCLUDE} -c $< -o $@
+
+clean:
+	$(RM) *.o *.gcno *.gcda

tcdistribution/PUSDistributor.cpp

@@ -0,0 +1,97 @@
+/*
+ * PUSDistributor.cpp
+ *
+ *  Created on: 18.06.2012
+ *      Author: baetz
+ */
+
+
+
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tcdistribution/CCSDSDistributorIF.h>
+#include <framework/tcdistribution/PUSDistributor.h>
+#include <framework/tmtcpacket/pus/TcPacketStored.h>
+#include <framework/tmtcservices/PusVerificationReport.h>
+
+PUSDistributor::PUSDistributor(uint16_t set_apid ) : TcDistributor(objects::PUS_PACKET_DISTRIBUTOR), checker(set_apid), verify_channel(),
+	current_packet(), tc_status(RETURN_FAILED) {
+
+}
+
+PUSDistributor::~PUSDistributor() {
+
+}
+
+iterator_t PUSDistributor::selectDestination() {
+//	debug << "PUSDistributor::handlePacket received: " << this->current_packet_id.store_index << ", " << this->current_packet_id.packet_index << std::endl;
+	iterator_t queueMapIt = this->queueMap.end();
+	this->current_packet.setStoreAddress( this->currentMessage.getStorageId() );
+	if ( current_packet.getWholeData() != NULL ) {
+		tc_status = checker.checkPacket( &current_packet );
+//		info << "PUSDistributor::handlePacket: packetCheck returned with " << (int)tc_status << std::endl;
+		uint32_t queue_id = current_packet.getService();
+		queueMapIt = this->queueMap.find( queue_id );
+	} else {
+		tc_status = PACKET_LOST;
+	}
+	if ( queueMapIt == this->queueMap.end() ) {
+		tc_status = DESTINATION_NOT_FOUND;
+	}
+
+	if ( tc_status != RETURN_OK ) {
+		debug << "PUSDistributor::handlePacket: error with " << (int)tc_status << std::endl;
+		return this->queueMap.end();
+	} else {
+		return queueMapIt;
+	}
+
+}
+
+
+//uint16_t PUSDistributor::createDestination( uint8_t service_id, uint8_t subservice_id ) {
+//	return ( service_id << 8 ) + subservice_id;
+//}
+
+ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
+	ReturnValue_t returnValue = RETURN_OK;
+	bool errorCode = true;
+	uint16_t serviceId = service->getIdentifier();
+	MessageQueueId_t queue = service->getRequestQueue();
+	errorCode = this->queueMap.insert( std::pair<uint32_t, MessageQueueId_t>( serviceId,  queue) ).second;
+	if(  errorCode == false ) {
+		returnValue = OSAL::RESOURCE_IN_USE;
+	}
+	return returnValue;
+}
+
+MessageQueueId_t PUSDistributor::getRequestQueue() {
+	return this->tcQueue.getId();
+}
+
+ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+	if ( queueStatus != RETURN_OK ) {
+		tc_status = queueStatus;
+	}
+	if ( tc_status != RETURN_OK ) {
+		this->verify_channel.sendFailureReport(  TC_VERIFY::ACCEPTANCE_FAILURE, &current_packet, tc_status );
+		//A failed packet is deleted immediately after reporting, otherwise it will block memory.
+		current_packet.deletePacket();
+		return RETURN_FAILED;
+	} else {
+		this->verify_channel.sendSuccessReport(  TC_VERIFY::ACCEPTANCE_SUCCESS, &current_packet );
+		return RETURN_OK;
+	}
+}
+
+uint16_t PUSDistributor::getIdentifier() {
+	return checker.getApid();
+}
+
+ReturnValue_t PUSDistributor::initialize() {
+	CCSDSDistributorIF* ccsdsDistributor = objectManager->get<CCSDSDistributorIF>(objects::CCSDS_PACKET_DISTRIBUTOR);
+	if (ccsdsDistributor == NULL) {
+		return RETURN_FAILED;
+	} else {
+		return ccsdsDistributor->registerApplication(this);
+	}
+}

tcdistribution/PUSDistributor.h

@@ -0,0 +1,71 @@
+/*
+ * PUSDistributor.h
+ *
+ *  Created on: 18.06.2012
+ *      Author: baetz
+ */
+
+#ifndef PUSDISTRIBUTOR_H_
+#define PUSDISTRIBUTOR_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/tcdistribution/PUSDistributorIF.h>
+#include <framework/tcdistribution/TcDistributor.h>
+#include <framework/tcdistribution/TcPacketCheck.h>
+#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
+#include <framework/tmtcservices/VerificationReporter.h>
+
+/**
+ * This class accepts PUS Telecommands and forwards them to Application services.
+ * In addition, the class performs a formal packet check and sends acceptance success
+ * or failure messages.
+ * \ingroup tc_distribution
+ */
+class PUSDistributor : public TcDistributor, public PUSDistributorIF, public AcceptsTelecommandsIF {
+protected:
+	/**
+	 * This attribute contains the class, that performs a formal packet check.
+	 */
+	TcPacketCheck checker;
+	/**
+	 * With this class, verification messages are sent to the TC Verification service.
+	 */
+	VerificationReporter verify_channel;
+	/**
+	 * The currently handled packet is stored here.
+	 */
+	TcPacketStored current_packet;
+	/**
+	 * With this variable, the current check status is stored to generate acceptance messages later.
+	 */
+	ReturnValue_t tc_status;
+	/**
+	 * This method reads the packet service, checks if such a service is registered and forwards the packet to the destination.
+	 * It also initiates the formal packet check and sending of verification messages.
+	 * @return Iterator to map entry of found service id or iterator to \c map.end().
+	 */
+	iterator_t selectDestination();
+	/**
+	 * The callback here handles the generation of acceptance success/failure messages.
+	 */
+	ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+public:
+	/**
+	 * The ctor passes \c set_apid to the checker class and calls the TcDistribution ctor with a certain object id.
+	 * @param set_apid The APID of this receiving Application.
+	 */
+	PUSDistributor( uint16_t set_apid );
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~PUSDistributor();
+	ReturnValue_t registerService( AcceptsTelecommandsIF* service );
+	MessageQueueId_t getRequestQueue();
+	uint16_t getIdentifier();
+	ReturnValue_t initialize();
+};
+
+
+
+
+#endif /* PUSDISTRIBUTOR_H_ */

tcdistribution/PUSDistributorIF.h

@@ -0,0 +1,33 @@
+/*
+ * PUSDistributorIF.h
+ *
+ *  Created on: 21.11.2012
+ *      Author: baetz
+ */
+
+#ifndef PUSDISTRIBUTORIF_H_
+#define PUSDISTRIBUTORIF_H_
+
+#include <framework/ipc/MessageQueue.h>
+#include <framework/tmtcservices/AcceptsTelecommandsIF.h>
+/**
+ * This interface allows PUS Services to register themselves at a PUS Distributor.
+ * \ingroup tc_distribution
+ */
+class PUSDistributorIF {
+public:
+	/**
+	 * The empty virtual destructor.
+	 */
+	virtual ~PUSDistributorIF() {
+	}
+/**
+ * With this method, Services can register themselves at the PUS Distributor.
+ * @param service A pointer to the registering Service.
+ * @return	- \c RETURN_OK on success,
+ * 			- \c RETURN_FAILED on failure.
+ */
+	virtual ReturnValue_t registerService( AcceptsTelecommandsIF* service ) = 0;
+};
+
+#endif /* PUSDISTRIBUTORIF_H_ */

tcdistribution/TcDistributor.cpp

@@ -0,0 +1,55 @@
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/ipc/MessageQueue.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/tcdistribution/TcDistributor.h>
+#include <framework/tmtcservices/TmTcMessage.h>
+
+TcDistributor::TcDistributor(object_id_t set_object_id) :
+		SystemObject(set_object_id), tcQueue(DISTRIBUTER_MAX_PACKETS) {
+
+}
+
+TcDistributor::~TcDistributor() {
+	//Nothing to do in the destructor, MQ's are destroyed elsewhere.
+}
+
+ReturnValue_t TcDistributor::performOperation(void) {
+	ReturnValue_t status = RETURN_OK;
+//	debug << "TcDistributor: performing Operation." << std::endl;
+	for (status = tcQueue.receiveMessage(&currentMessage); status == RETURN_OK;
+			status = tcQueue.receiveMessage(&currentMessage)) {
+		status = handlePacket();
+	}
+	if (status == OSAL::QUEUE_EMPTY) {
+		return RETURN_OK;
+	} else {
+		return status;
+	}
+}
+
+ReturnValue_t TcDistributor::handlePacket() {
+
+	iterator_t queueMapIt = this->selectDestination();
+	ReturnValue_t returnValue = RETURN_FAILED;
+	if (queueMapIt != this->queueMap.end()) {
+		returnValue = this->tcQueue.sendMessage(queueMapIt->second,
+				&this->currentMessage);
+	}
+	return this->callbackAfterSending(returnValue);
+}
+
+void TcDistributor::print() {
+	debug << "Distributor content is: " << std::endl << "ID\t| message queue id"
+			<< std::endl;
+	for (iterator_t it = this->queueMap.begin(); it != this->queueMap.end();
+			it++) {
+		debug << it->first << "\t| 0x" << std::hex << it->second << std::dec
+				<< std::endl;
+	}
+	debug << std::dec;
+
+}
+
+ReturnValue_t TcDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+	return RETURN_OK;
+}

tcdistribution/TcDistributor.h

@@ -0,0 +1,117 @@
+#ifndef TCDISTRIBUTOR_H_
+#define TCDISTRIBUTOR_H_
+#include <framework/ipc/MessageQueue.h>
+#include <framework/objectmanager/ObjectManagerIF.h>
+#include <framework/objectmanager/SystemObject.h>
+#include <framework/osal/OSAL.h>
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/tasks/ExecutableObjectIF.h>
+#include <framework/tmtcservices/TmTcMessage.h>
+#include <map>
+
+
+/**
+ * \defgroup tc_distribution Telecommand Distribution
+ * All classes associated with Routing and Distribution of Telecommands belong to this group.
+ */
+
+/**
+ * This typedef simplifies writing down the \c map iterator.
+ */
+typedef std::map<uint32_t, MessageQueueId_t>::iterator iterator_t;
+
+/**
+ * This is the base class to implement distributors for Space Packets.
+ * Typically, the distribution is required to forward Telecommand packets
+ * over the satellite applications and services. The class receives
+ * Space Packets over a message queue and holds a map that links other
+ * message queue ids to some identifier. The process of unpacking the
+ * destination information from the packet is handled by the child class
+ * implementations.
+ * \ingroup tc_distribution
+ */
+class TcDistributor : public SystemObject, public ExecutableObjectIF, public HasReturnvaluesIF {
+private:
+	/**
+	 * This constant sets the maximum number of packets distributed per call.
+	 */
+	static const uint8_t DISTRIBUTER_MAX_PACKETS = 128;
+protected:
+	/**
+	 * This is the receiving queue for incoming Telecommands.
+	 * The child classes must make its queue id public.
+	 */
+	MessageQueue tcQueue;
+	/**
+	 * The last received incoming packet information is stored in this
+	 * member.
+	 * As different child classes unpack the incoming packet differently
+	 * (i.e. as a CCSDS Space Packet or as a PUS Telecommand Packet), it
+	 * is not tried to unpack the packet information within this class.
+	 */
+	TmTcMessage currentMessage;
+	/**
+	 * The map that links certain packet information to a destination.
+	 * The packet information may be the APID of the packet or the service
+	 * identifier. Filling of the map is under control of the different child
+	 * classes.
+	 */
+	std::map<uint32_t, MessageQueueId_t> queueMap;
+	/**
+	 * This method shall unpack the routing information from the incoming
+	 * packet and select the map entry which represents the packet's target.
+	 * @return	An iterator to the map element to forward to or queuMap.end().
+	 */
+	virtual iterator_t selectDestination() = 0;
+	/**
+	 * The handlePacket method calls the child class's selectDestination method
+	 * and forwards the packet to its destination, if found.
+	 * @return The message queue return value or \c RETURN_FAILED, in case no
+	 * 		destination was found.
+	 */
+	ReturnValue_t handlePacket();
+	/**
+	 * This method gives the child class a chance to perform some kind of operation
+	 * after the parent tried to forward the message.
+	 * A typically application would be sending success/failure messages.
+	 * The default implementation just returns \c RETURN_OK.
+	 * @param queueStatus	The status of the message queue after an attempt to send the TC.
+	 * @return	- \c RETURN_OK on success
+	 * 			- \c RETURN_FAILED on failure
+	 */
+	virtual ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus );
+public:
+	static const uint8_t INTERFACE_ID = PACKET_DISTRIBUTION;
+	static const ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
+	static const ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	/**
+	 * Within the default constructor, the SystemObject id is set and the
+	 * message queue is initialized.
+	 * Filling the map is under control of the child classes.
+	 * @param set_object_id	This id is assigned to the distributor
+	 * 		implementation.
+	 */
+	TcDistributor( object_id_t set_object_id );
+	/**
+	 * The destructor is empty, the message queues are not in the vicinity of
+	 * this class.
+	 */
+	virtual ~TcDistributor();
+	/**
+	 * The method is called cyclically and fetches new incoming packets from
+	 * the message queue.
+	 * In case a new packet is found, it calls the handlePacket method to deal
+	 * with distribution.
+	 * @return The error code of the message queue call.
+	 */
+	ReturnValue_t performOperation();
+	/**
+	 * A simple debug print, that prints all distribution information stored in
+	 * queueMap.
+	 */
+	void print();
+};
+
+
+#endif /* TCDISTRIBUTOR_H_ */

tcdistribution/TcPacketCheck.cpp

@@ -0,0 +1,45 @@
+/*
+ * TcPacketCheck.cpp
+ *
+ *  Created on: 19.06.2012
+ *      Author: baetz
+ */
+
+
+#include <framework/globalfunctions/crc_ccitt.h>
+#include <framework/serviceinterface/ServiceInterfaceStream.h>
+#include <framework/storagemanager/StorageManagerIF.h>
+#include <framework/tcdistribution/TcPacketCheck.h>
+#include <framework/tmtcservices/VerificationCodes.h>
+
+TcPacketCheck::TcPacketCheck( uint16_t set_apid ) : apid(set_apid) {
+}
+
+ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* current_packet ) {
+	uint16_t calculated_crc = ::Calculate_CRC ( current_packet->getWholeData(), current_packet->getFullSize() );
+	if ( calculated_crc != 0 ) {
+		return INCORRECT_CHECKSUM;
+	}
+	bool condition = !(current_packet->hasSecondaryHeader()) ||
+			current_packet->getPacketVersionNumber() != CCSDS_VERSION_NUMBER ||
+			!(current_packet->isTelecommand());
+	if ( condition ) {
+		return INCORRECT_PRIMARY_HEADER;
+	}
+	if ( current_packet->getAPID() != this->apid )
+		return ILLEGAL_APID;
+
+	if ( !current_packet->isSizeCorrect() ) {
+		return INCOMPLETE_PACKET;
+	}
+	condition = (current_packet->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
+			(current_packet->getPusVersionNumber() != PUS_VERSION_NUMBER);
+	if ( condition ) {
+		return INCORRECT_SECONDARY_HEADER;
+	}
+	return RETURN_OK;
+}
+
+uint16_t TcPacketCheck::getApid() const {
+	return apid;
+}

tcdistribution/TcPacketCheck.h

@@ -0,0 +1,66 @@
+/*
+ * TcPacketCheck.h
+ *
+ *  Created on: 19.06.2012
+ *      Author: baetz
+ */
+
+#ifndef TCPACKETCHECK_H_
+#define TCPACKETCHECK_H_
+
+#include <framework/returnvalues/HasReturnvaluesIF.h>
+#include <framework/tmtcpacket/pus/TcPacketStored.h>
+#include <framework/tmtcservices/PusVerificationReport.h>
+/**
+ * This class performs a formal packet check for incoming PUS Telecommand Packets.
+ * Currently, it only checks if the APID and CRC are correct.
+ * \ingroup tc_distribution
+ */
+class TcPacketCheck : public HasReturnvaluesIF {
+protected:
+	/**
+	 * Describes the version number a packet must have to pass.
+	 */
+	static const uint8_t CCSDS_VERSION_NUMBER = 0;
+	/**
+	 * Describes the secondary header a packet must have to pass.
+	 */
+	static const uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
+	/**
+	 * Describes the TC Packet PUS Version Number a packet must have to pass.
+	 */
+	static const uint8_t PUS_VERSION_NUMBER = 1;
+	/**
+	 * The packet id each correct packet should have.
+	 * It is composed of the APID and some static fields.
+	 */
+	uint16_t apid;
+public:
+	static const uint8_t INTERFACE_ID = TC_PACKET_CHECK;
+	static const ReturnValue_t ILLEGAL_APID = MAKE_RETURN_CODE( 0 );
+	static const ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE( 1 );
+	static const ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE( 2 );
+	static const ReturnValue_t ILLEGAL_PACKET_TYPE = MAKE_RETURN_CODE( 3 );
+	static const ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE( 4 );
+	static const ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE( 5 );
+	static const ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE( 6 );
+	/**
+	 * The constructor only sets the APID attribute.
+	 * @param set_apid The APID to set.
+	 */
+	TcPacketCheck( uint16_t set_apid );
+	/**
+	 * This is the actual method to formally check a certain Telecommand Packet.
+	 * The packet's Application Data can not be checked here.
+	 * @param current_packet The packt to check
+	 * @return	- \c RETURN_OK on success.
+	 * 			- \c INCORRECT_CHECKSUM if checksum is invalid.
+	 * 			- \c ILLEGAL_APID if APID does not match.
+	 */
+	ReturnValue_t checkPacket( TcPacketStored* current_packet );
+
+	uint16_t getApid() const;
+};
+
+
+#endif /* TCPACKETCHECK_H_ */