release 0.0.1 of fsfw added as a core

fsfw/tcdistribution/CCSDSDistributor.cpp

@@ -0,0 +1,86 @@
+#include "CCSDSDistributor.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcpacket/SpacePacketBase.h"
+
+CCSDSDistributor::CCSDSDistributor(uint16_t setDefaultApid,
+		object_id_t setObjectId):
+		TcDistributor(setObjectId), defaultApid( setDefaultApid ) {
+}
+
+CCSDSDistributor::~CCSDSDistributor() {}
+
+TcDistributor::TcMqMapIter CCSDSDistributor::selectDestination() {
+//	sif::debug << "CCSDSDistributor::selectDestination received: " <<
+//			this->currentMessage.getStorageId().pool_index << ", " <<
+//			this->currentMessage.getStorageId().packet_index << std::endl;
+	const uint8_t* packet = nullptr;
+	size_t size = 0;
+	ReturnValue_t result = this->tcStore->getData(currentMessage.getStorageId(),
+			&packet, &size );
+	if(result != HasReturnvaluesIF::RETURN_OK) {
+		sif::error << "CCSDSDistributor::selectDestination: Getting data from"
+				" store failed!" << std::endl;
+	}
+	SpacePacketBase currentPacket(packet);
+
+//	sif:: info << "CCSDSDistributor::selectDestination has packet with APID "
+//			<< std::hex << currentPacket.getAPID() << std::dec << std::endl;
+	TcMqMapIter position = this->queueMap.find(currentPacket.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->defaultApid );
+	}
+}
+
+MessageQueueId_t CCSDSDistributor::getRequestQueue() {
+	return tcQueue->getId();
+}
+
+ReturnValue_t CCSDSDistributor::registerApplication(
+		AcceptsTelecommandsIF* application) {
+	ReturnValue_t returnValue = RETURN_OK;
+	auto insertPair = this->queueMap.emplace(application->getIdentifier(),
+	        application->getRequestQueue());
+	if(not insertPair.second) {
+		returnValue = RETURN_FAILED;
+	}
+	return returnValue;
+}
+
+ReturnValue_t CCSDSDistributor::registerApplication(uint16_t apid,
+		MessageQueueId_t id) {
+	ReturnValue_t returnValue = RETURN_OK;
+	auto insertPair = this->queueMap.emplace(apid, id);
+	if(not insertPair.second) {
+		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 == nullptr) {
+	    sif::error << "CCSDSDistributor::initialize: Could not initialize"
+	            " TC store!" << std::endl;
+	    status = RETURN_FAILED;
+	}
+	return status;
+}
+
+ReturnValue_t CCSDSDistributor::callbackAfterSending(
+		ReturnValue_t queueStatus) {
+	if (queueStatus != RETURN_OK) {
+		tcStore->deleteData(currentMessage.getStorageId());
+	}
+	return RETURN_OK;
+}

fsfw/tcdistribution/CCSDSDistributor.h

@@ -0,0 +1,71 @@
+#ifndef FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
+#define FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tcdistribution/CCSDSDistributorIF.h"
+#include "../tcdistribution/TcDistributor.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+
+/**
+ * @brief 	An instantiation of the CCSDSDistributorIF.
+ * @details
+ * 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 {
+public:
+	/**
+	 * @brief	The constructor sets the default APID and calls the
+	 * 			TcDistributor ctor with a certain object id.
+	 * @details
+	 * @c tcStore is set in the @c initialize method.
+	 * @param setDefaultApid The default APID, where packets with unknown
+	 * destination are sent to.
+	 */
+	CCSDSDistributor(uint16_t setDefaultApid, object_id_t setObjectId);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~CCSDSDistributor();
+
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t registerApplication( uint16_t apid,
+			MessageQueueId_t id) override;
+	ReturnValue_t registerApplication(
+			AcceptsTelecommandsIF* application) override;
+	uint16_t getIdentifier() override;
+	ReturnValue_t initialize() override;
+
+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 defaultApid,
+	 * where a Acceptance Failure message should be generated.
+	 * @return Iterator to map entry of found APID or iterator to default APID.
+	 */
+	TcMqMapIter selectDestination() override;
+    /**
+     * The callback here handles the generation of acceptance
+     * success/failure messages.
+     */
+    ReturnValue_t callbackAfterSending( ReturnValue_t queueStatus ) override;
+
+	/**
+	 * The default APID, where packets with unknown APID are sent to.
+	 */
+	uint16_t defaultApid;
+	/**
+	 * A reference to the TC storage must be maintained, as this class handles
+	 * pure Space Packets and there exists no SpacePacketStored class.
+	 */
+	StorageManagerIF* tcStore = nullptr;
+
+};
+
+#endif /* FRAMEWORK_TCDISTRIBUTION_CCSDSDISTRIBUTOR_H_ */

fsfw/tcdistribution/CCSDSDistributorIF.h

@@ -0,0 +1,44 @@
+#ifndef FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_
+#define FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_
+
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../ipc/MessageQueueSenderIF.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 /* FSFW_TCDISTRIBUTION_CCSDSDISTRIBUTORIF_H_ */

fsfw/tcdistribution/PUSDistributor.cpp

@@ -0,0 +1,113 @@
+#include "CCSDSDistributorIF.h"
+#include "PUSDistributor.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../tmtcservices/PusVerificationReport.h"
+
+PUSDistributor::PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+		object_id_t setPacketSource) :
+		TcDistributor(setObjectId), checker(setApid), verifyChannel(),
+		tcStatus(RETURN_FAILED), packetSource(setPacketSource) {}
+
+PUSDistributor::~PUSDistributor() {}
+
+PUSDistributor::TcMqMapIter PUSDistributor::selectDestination() {
+    // sif:: debug << "PUSDistributor::handlePacket received: "
+    //          << this->current_packet_id.store_index << ", "
+    //          << this->current_packet_id.packet_index << std::endl;
+    TcMqMapIter queueMapIt = this->queueMap.end();
+    if(this->currentPacket == nullptr) {
+        return queueMapIt;
+    }
+    this->currentPacket->setStoreAddress(this->currentMessage.getStorageId());
+    if (currentPacket->getWholeData() != nullptr) {
+        tcStatus = checker.checkPacket(currentPacket);
+#ifdef DEBUG
+        if(tcStatus != HasReturnvaluesIF::RETURN_OK) {
+            sif::debug << "PUSDistributor::handlePacket: Packet format "
+                    << "invalid, code "<< static_cast<int>(tcStatus)
+                    << std::endl;
+        }
+#endif
+        uint32_t queue_id = currentPacket->getService();
+        queueMapIt = this->queueMap.find(queue_id);
+    }
+    else {
+        tcStatus = PACKET_LOST;
+    }
+
+    if (queueMapIt == this->queueMap.end()) {
+        tcStatus = DESTINATION_NOT_FOUND;
+#ifdef DEBUG
+        sif::debug << "PUSDistributor::handlePacket: Destination not found, "
+                << "code "<< static_cast<int>(tcStatus) << std::endl;
+#endif
+    }
+
+    if (tcStatus != RETURN_OK) {
+        return this->queueMap.end();
+    }
+    else {
+        return queueMapIt;
+    }
+
+}
+
+
+ReturnValue_t PUSDistributor::registerService(AcceptsTelecommandsIF* service) {
+	uint16_t serviceId = service->getIdentifier();
+	// sif::info << "Service ID: " << (int)serviceId << std::endl;
+	MessageQueueId_t queue = service->getRequestQueue();
+	auto returnPair = queueMap.emplace(serviceId, queue);
+	if (not returnPair.second) {
+		sif::error << "PUSDistributor::registerService: Service ID already"
+				" exists in map." << std::endl;
+		return SERVICE_ID_ALREADY_EXISTS;
+	}
+	return HasReturnvaluesIF::RETURN_OK;
+}
+
+MessageQueueId_t PUSDistributor::getRequestQueue() {
+	return tcQueue->getId();
+}
+
+ReturnValue_t PUSDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+	if (queueStatus != RETURN_OK) {
+		tcStatus = queueStatus;
+	}
+	if (tcStatus != RETURN_OK) {
+		this->verifyChannel.sendFailureReport(TC_VERIFY::ACCEPTANCE_FAILURE,
+				currentPacket, tcStatus);
+		// A failed packet is deleted immediately after reporting,
+		// otherwise it will block memory.
+		currentPacket->deletePacket();
+		return RETURN_FAILED;
+	} else {
+		this->verifyChannel.sendSuccessReport(TC_VERIFY::ACCEPTANCE_SUCCESS,
+				currentPacket);
+		return RETURN_OK;
+	}
+}
+
+uint16_t PUSDistributor::getIdentifier() {
+	return checker.getApid();
+}
+
+ReturnValue_t PUSDistributor::initialize() {
+    currentPacket = new TcPacketStored();
+    if(currentPacket == nullptr) {
+        // Should not happen, memory allocation failed!
+        return ObjectManagerIF::CHILD_INIT_FAILED;
+    }
+
+	CCSDSDistributorIF* ccsdsDistributor =
+			objectManager->get<CCSDSDistributorIF>(packetSource);
+	if (ccsdsDistributor == nullptr) {
+		sif::error << "PUSDistributor::initialize: Packet source invalid."
+		        << " Make sure it exists and implements CCSDSDistributorIF!"
+		        << std::endl;
+	    return RETURN_FAILED;
+	}
+	return ccsdsDistributor->registerApplication(this);
+}

fsfw/tcdistribution/PUSDistributor.h

@@ -0,0 +1,79 @@
+#ifndef FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+#define FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_
+
+#include "PUSDistributorIF.h"
+#include "TcDistributor.h"
+#include "TcPacketCheck.h"
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../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 {
+public:
+	/**
+	 * The ctor passes @c set_apid to the checker class and calls the
+	 * TcDistribution ctor with a certain object id.
+	 * @param setApid The APID of this receiving Application.
+	 * @param setObjectId Object ID of the distributor itself
+	 * @param setPacketSource Object ID of the source of TC packets.
+	 * Must implement CCSDSDistributorIF.
+	 */
+	PUSDistributor(uint16_t setApid, object_id_t setObjectId,
+			object_id_t setPacketSource);
+	/**
+	 * The destructor is empty.
+	 */
+	virtual ~PUSDistributor();
+	ReturnValue_t registerService(AcceptsTelecommandsIF* service) override;
+	MessageQueueId_t getRequestQueue() override;
+	ReturnValue_t initialize() override;
+	uint16_t getIdentifier() override;
+
+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 verifyChannel;
+	/**
+	 * The currently handled packet is stored here.
+	 */
+	TcPacketStored* currentPacket = nullptr;
+	/**
+	 * With this variable, the current check status is stored to generate
+	 * acceptance messages later.
+	 */
+	ReturnValue_t tcStatus;
+
+	const object_id_t packetSource;
+
+	/**
+	 * 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().
+	 */
+	TcMqMapIter selectDestination() override;
+	/**
+	 * The callback here handles the generation of acceptance
+	 * success/failure messages.
+	 */
+	ReturnValue_t callbackAfterSending(ReturnValue_t queueStatus) override;
+};
+
+#endif /* FSFW_TCDISTRIBUTION_PUSDISTRIBUTOR_H_ */

fsfw/tcdistribution/PUSDistributorIF.h

@@ -0,0 +1,27 @@
+#ifndef FSFW_TCDISTRIBUTION_PUSDISTRIBUTORIF_H_
+#define FSFW_TCDISTRIBUTION_PUSDISTRIBUTORIF_H_
+
+#include "../tmtcservices/AcceptsTelecommandsIF.h"
+#include "../ipc/MessageQueueSenderIF.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 /* FSFW_TCDISTRIBUTION_PUSDISTRIBUTORIF_H_ */

fsfw/tcdistribution/TcDistributor.cpp

@@ -0,0 +1,55 @@
+#include "TcDistributor.h"
+
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/QueueFactory.h"
+
+TcDistributor::TcDistributor(object_id_t objectId) :
+		SystemObject(objectId) {
+	tcQueue = QueueFactory::instance()->
+	        createMessageQueue(DISTRIBUTER_MAX_PACKETS);
+}
+
+TcDistributor::~TcDistributor() {
+	QueueFactory::instance()->deleteMessageQueue(tcQueue);
+}
+
+ReturnValue_t TcDistributor::performOperation(uint8_t opCode) {
+	ReturnValue_t status = RETURN_OK;
+	for (status = tcQueue->receiveMessage(&currentMessage); status == RETURN_OK;
+			status = tcQueue->receiveMessage(&currentMessage)) {
+		status = handlePacket();
+	}
+	if (status == MessageQueueIF::EMPTY) {
+		return RETURN_OK;
+	} else {
+		return status;
+	}
+}
+
+ReturnValue_t TcDistributor::handlePacket() {
+
+	TcMqMapIter 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() {
+	sif::debug << "Distributor content is: " << std::endl
+	        << "ID\t| Message Queue ID" << std::endl;
+	sif::debug << std::setfill('0') << std::setw(8) << std::hex;
+	for (const auto& queueMapIter: queueMap) {
+		sif::debug << queueMapIter.first << "\t| 0x"   << queueMapIter.second
+		         << std::endl;
+	}
+	sif::debug << std::setfill(' ') << std::dec;
+
+}
+
+ReturnValue_t TcDistributor::callbackAfterSending(ReturnValue_t queueStatus) {
+	return RETURN_OK;
+}

fsfw/tcdistribution/TcDistributor.h

@@ -0,0 +1,122 @@
+#ifndef FSFW_TMTCSERVICES_TCDISTRIBUTOR_H_
+#define FSFW_TMTCSERVICES_TCDISTRIBUTOR_H_
+
+#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/SystemObject.h"
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tasks/ExecutableObjectIF.h"
+#include "../tmtcservices/TmTcMessage.h"
+#include "../ipc/MessageQueueIF.h"
+#include <map>
+
+/**
+ * @defgroup tc_distribution Telecommand Distribution
+ * All classes associated with Routing and Distribution of Telecommands
+ * belong to this group.
+ */
+
+
+/**
+ * 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 {
+public:
+	using TcMessageQueueMap = std::map<uint32_t, MessageQueueId_t>;
+	using TcMqMapIter = std::map<uint32_t, MessageQueueId_t>::iterator;
+
+	static constexpr uint8_t INTERFACE_ID = CLASS_ID::PACKET_DISTRIBUTION;
+	static constexpr ReturnValue_t PACKET_LOST = MAKE_RETURN_CODE( 1 );
+	static constexpr ReturnValue_t DESTINATION_NOT_FOUND = MAKE_RETURN_CODE( 2 );
+	static constexpr ReturnValue_t SERVICE_ID_ALREADY_EXISTS = MAKE_RETURN_CODE(3);
+	/**
+	 * 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 objectId);
+	/**
+	 * 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(uint8_t opCode);
+	/**
+	 * A simple debug print, that prints all distribution information stored in
+	 * queueMap.
+	 */
+	void print();
+
+protected:
+	/**
+	 * This is the receiving queue for incoming Telecommands.
+	 * The child classes must make its queue id public.
+	 */
+	MessageQueueIF* tcQueue = nullptr;
+	/**
+	 * 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.
+	 */
+	TcMessageQueueMap 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 TcMqMapIter 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 );
+
+private:
+	/**
+	 * This constant sets the maximum number of packets distributed per call.
+	 */
+	static constexpr uint8_t DISTRIBUTER_MAX_PACKETS = 128;
+};
+
+
+#endif /* FSFW_TMTCSERVICES_TCDISTRIBUTOR_H_ */

fsfw/tcdistribution/TcPacketCheck.cpp

@@ -0,0 +1,39 @@
+#include "TcPacketCheck.h"
+
+#include "../globalfunctions/CRC.h"
+#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../storagemanager/StorageManagerIF.h"
+#include "../tmtcservices/VerificationCodes.h"
+
+TcPacketCheck::TcPacketCheck( uint16_t setApid ) : apid(setApid) {
+}
+
+ReturnValue_t TcPacketCheck::checkPacket( TcPacketStored* currentPacket ) {
+	uint16_t calculated_crc = CRC::crc16ccitt( currentPacket->getWholeData(),
+	        currentPacket->getFullSize() );
+	if ( calculated_crc != 0 ) {
+		return INCORRECT_CHECKSUM;
+	}
+	bool condition = (not currentPacket->hasSecondaryHeader()) or
+			(currentPacket->getPacketVersionNumber() != CCSDS_VERSION_NUMBER) or
+			(not currentPacket->isTelecommand());
+	if ( condition ) {
+		return INCORRECT_PRIMARY_HEADER;
+	}
+	if ( currentPacket->getAPID() != this->apid )
+		return ILLEGAL_APID;
+
+	if ( not currentPacket->isSizeCorrect() ) {
+		return INCOMPLETE_PACKET;
+	}
+	condition = (currentPacket->getSecondaryHeaderFlag() != CCSDS_SECONDARY_HEADER_FLAG) ||
+			(currentPacket->getPusVersionNumber() != PUS_VERSION_NUMBER);
+	if ( condition ) {
+		return INCORRECT_SECONDARY_HEADER;
+	}
+	return RETURN_OK;
+}
+
+uint16_t TcPacketCheck::getApid() const {
+	return apid;
+}

fsfw/tcdistribution/TcPacketCheck.h

@@ -0,0 +1,60 @@
+#ifndef FSFW_TCDISTRIBUTION_TCPACKETCHECK_H_
+#define FSFW_TCDISTRIBUTION_TCPACKETCHECK_H_
+
+#include "../returnvalues/HasReturnvaluesIF.h"
+#include "../tmtcpacket/pus/TcPacketStored.h"
+#include "../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 constexpr uint8_t CCSDS_VERSION_NUMBER = 0;
+	/**
+	 * Describes the secondary header a packet must have to pass.
+	 */
+	static constexpr uint8_t CCSDS_SECONDARY_HEADER_FLAG = 0;
+	/**
+	 * Describes the TC Packet PUS Version Number a packet must have to pass.
+	 */
+	static constexpr 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 = CLASS_ID::TC_PACKET_CHECK;
+	static const ReturnValue_t ILLEGAL_APID = MAKE_RETURN_CODE( 0 );
+	static const ReturnValue_t INCOMPLETE_PACKET = MAKE_RETURN_CODE( 1 );
+	static const ReturnValue_t INCORRECT_CHECKSUM = MAKE_RETURN_CODE( 2 );
+	static const ReturnValue_t ILLEGAL_PACKET_TYPE = MAKE_RETURN_CODE( 3 );
+	static const ReturnValue_t ILLEGAL_PACKET_SUBTYPE = MAKE_RETURN_CODE( 4 );
+	static const ReturnValue_t INCORRECT_PRIMARY_HEADER = MAKE_RETURN_CODE( 5 );
+	static const ReturnValue_t INCORRECT_SECONDARY_HEADER = MAKE_RETURN_CODE( 6 );
+	/**
+	 * The constructor only sets the APID attribute.
+	 * @param set_apid The APID to set.
+	 */
+	TcPacketCheck( uint16_t setApid );
+	/**
+	 * 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* currentPacket );
+
+	uint16_t getApid() const;
+};
+
+
+#endif /* FSFW_TCDISTRIBUTION_TCPACKETCHECK_H_ */