boolean addTaskIF removed

PeriodicPOsixTask: taskIF added always now
2020-08-04 14:37:06 +02:00
26 changed files with 108 additions and 1690 deletions
--- a/container/ArrayList.h
+++ b/container/ArrayList.h
@ -72,15 +72,11 @@ public:
 			return tmp;
 		}

-		T& operator*(){
+		T operator*() {
 			return *value;
 		}

-		const T& operator*() const{
-			return *value;
-		}
-
-		T *operator->(){
+		T *operator->() {
 			return value;
 		}

--- a/container/FixedMap.h
+++ b/container/FixedMap.h
@ -1,5 +1,5 @@
-#ifndef FRAMEWORK_CONTAINER_FIXEDMAP_H_
-#define FRAMEWORK_CONTAINER_FIXEDMAP_H_
+#ifndef FIXEDMAP_H_
+#define FIXEDMAP_H_

 #include <framework/container/ArrayList.h>
 #include <framework/returnvalues/HasReturnvaluesIF.h>
@ -7,10 +7,6 @@

 /**
 * \ingroup container
- *
- *
- *  \warning Iterators return a non-const key_t in the pair.
- *  \warning A User is not allowed to change the key, otherwise the map is corrupted.
 */
 template<typename key_t, typename T>
 class FixedMap: public SerializeIF {
@ -51,6 +47,15 @@ public:
 		Iterator(std::pair<key_t, T> *pair) :
 				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
 		}
+
+		T operator*() {
+			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
+
+		T *operator->() {
+			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
+
 	};

 	Iterator begin() const {
@ -65,7 +70,7 @@ public:
 		return _size;
 	}

-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
+	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
 		if (exists(key) == HasReturnvaluesIF::RETURN_OK) {
 			return KEY_ALREADY_EXISTS;
 		}
@ -74,7 +79,7 @@ public:
 		}
 		theMap[_size].first = key;
 		theMap[_size].second = value;
-		if (storedValue != nullptr) {
+		if (storedValue != NULL) {
 			*storedValue = Iterator(&theMap[_size]);
 		}
 		++_size;
@ -82,7 +87,7 @@ public:
 	}

 	ReturnValue_t insert(std::pair<key_t, T> pair) {
-		return insert(pair.first, pair.second);
+		return insert(pair.fist, pair.second);
 	}

 	ReturnValue_t exists(key_t key) const {
--- a/container/FixedOrderedMultimap.h
+++ b/container/FixedOrderedMultimap.h
@ -48,7 +48,7 @@ private:
 		if (_size <= position) {
 			return;
 		}
-		memmove(static_cast<void*>(&theMap[position]), static_cast<void*>(&theMap[position + 1]),
+		memmove(&theMap[position], &theMap[position + 1],
 				(_size - position - 1) * sizeof(std::pair<key_t,T>));
 		--_size;
 	}
@ -68,6 +68,15 @@ public:
 		Iterator(std::pair<key_t, T> *pair) :
 				ArrayList<std::pair<key_t, T>, uint32_t>::Iterator(pair) {
 		}
+
+		T operator*() {
+			return ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
+
+		T *operator->() {
+			return &ArrayList<std::pair<key_t, T>, uint32_t>::Iterator::value->second;
+		}
+
 	};

 	Iterator begin() const {
@ -82,17 +91,17 @@ public:
 		return _size;
 	}

-	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = nullptr) {
+	ReturnValue_t insert(key_t key, T value, Iterator *storedValue = NULL) {
 		if (_size == theMap.maxSize()) {
 			return MAP_FULL;
 		}
 		uint32_t position = findNicePlace(key);
-		memmove(static_cast<void*>(&theMap[position + 1]),static_cast<void*>(&theMap[position]),
+		memmove(&theMap[position + 1], &theMap[position],
 				(_size - position) * sizeof(std::pair<key_t,T>));
 		theMap[position].first = key;
 		theMap[position].second = value;
 		++_size;
-		if (storedValue != nullptr) {
+		if (storedValue != NULL) {
 			*storedValue = Iterator(&theMap[position]);
 		}
 		return HasReturnvaluesIF::RETURN_OK;
@ -136,6 +145,12 @@ public:
 		return HasReturnvaluesIF::RETURN_OK;
 	}

+	//This is potentially unsafe
+//	T *findValue(key_t key) const {
+//		return &theMap[findFirstIndex(key)].second;
+//	}
+
+
 	Iterator find(key_t key) const {
 		ReturnValue_t result = exists(key);
 		if (result != HasReturnvaluesIF::RETURN_OK) {
--- a/events/fwSubsystemIdRanges.h
+++ b/events/fwSubsystemIdRanges.h
@ -18,8 +18,6 @@ enum {
 	SYSTEM_MANAGER = 74,
 	SYSTEM_MANAGER_1 = 75,
 	SYSTEM_1 = 79,
-	PUS_SERVICE_1 = 80,
-	FW_SUBSYSTEM_ID_RANGE
 };
 }

--- a/framework.mk
+++ b/framework.mk
@ -34,7 +34,7 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/FreeRTOS/*.cpp)
 else ifeq ($(OS_FSFW),host)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/osal/host/*.cpp)
 else
-$(error invalid OS_FSFW specified, valid OS_FSFW are rtems, linux, freeRTOS, host)
+$(error invalid OS specified, valid OS are rtems, linux, freeRTOS, host)
 endif

 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/parameters/*.cpp)
@ -55,4 +55,3 @@ CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/packetmatcher/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcpacket/pus/*.cpp)
 CXXSRC += $(wildcard $(FRAMEWORK_PATH)/tmtcservices/*.cpp)
-CXXSRC += $(wildcard $(FRAMEWORK_PATH)/pus/*.cpp)
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@ -21,14 +21,14 @@ void* PeriodicPosixTask::taskEntryPoint(void* arg) {
 	return NULL;
 }

-ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object,
-        bool addTaskIF) {
+ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
 	objectList.push_back(newObject);
+
 	newObject->setTaskIF(this);

 	return HasReturnvaluesIF::RETURN_OK;
--- a/osal/linux/PeriodicPosixTask.h
+++ b/osal/linux/PeriodicPosixTask.h
@ -39,8 +39,7 @@ public:
 	 * @param object Id of the object to add.
 	 * @return RETURN_OK on success, RETURN_FAILED if the object could not be added.
 	 */
-	ReturnValue_t addComponent(object_id_t object,
-	        bool addTaskIF = true) override;
+	ReturnValue_t addComponent(object_id_t object) override;

 	uint32_t getPeriodMs() const override;

--- a/pus/CService200ModeCommanding.cpp
+++ b/pus/CService200ModeCommanding.cpp
@ -1,119 +0,0 @@
-#include <framework/pus/CService200ModeCommanding.h>
-#include <framework/pus/servicepackets/Service200Packets.h>
-
-#include <framework/modes/HasModesIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/modes/ModeMessage.h>
-
-CService200ModeCommanding::CService200ModeCommanding(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId):
-        CommandingServiceBase(objectId, apid, serviceId,
-	    NUMBER_OF_PARALLEL_COMMANDS,COMMAND_TIMEOUT_SECONDS) {}
-
-CService200ModeCommanding::~CService200ModeCommanding() {}
-
-ReturnValue_t CService200ModeCommanding::isValidSubservice(uint8_t subservice) {
-	switch(subservice) {
-	case(Subservice::COMMAND_MODE_COMMAND):
-	case(Subservice::COMMAND_MODE_READ):
-	case(Subservice::COMMAND_MODE_ANNCOUNCE):
-		return RETURN_OK;
-	default:
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-
-ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject(
-		uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-		MessageQueueId_t *id, object_id_t *objectId) {
-    if(tcDataLen < sizeof(object_id_t)) {
-        return CommandingServiceBase::INVALID_TC;
-    }
-    SerializeAdapter::deSerialize(objectId, &tcData, &tcDataLen,
-            SerializeIF::Endianness::BIG);
-
-	return checkInterfaceAndAcquireMessageQueue(id,objectId);
-}
-
-ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
-        MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
-    HasModesIF * destination = objectManager->get<HasModesIF>(*objectId);
-    if(destination == nullptr) {
-        return CommandingServiceBase::INVALID_OBJECT;
-
-    }
-
-    *messageQueueToSet = destination->getCommandQueue();
-    return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t CService200ModeCommanding::prepareCommand(
-		CommandMessage* message,uint8_t subservice, const uint8_t *tcData,
-		size_t tcDataLen, uint32_t *state, object_id_t objectId) {
-	ModePacket modeCommandPacket;
-	ReturnValue_t result = modeCommandPacket.deSerialize(&tcData,
-			&tcDataLen, SerializeIF::Endianness::BIG);
-	if (result != RETURN_OK) {
-		return result;
-	}
-
-	ModeMessage::setModeMessage(dynamic_cast<CommandMessage*>(message),
-	        ModeMessage::CMD_MODE_COMMAND, modeCommandPacket.getMode(),
-	        modeCommandPacket.getSubmode());
-	return result;
-}
-
-
-ReturnValue_t CService200ModeCommanding::handleReply(
-		const CommandMessage* reply, Command_t previousCommand,
-		uint32_t *state, CommandMessage* optionalNextCommand,
-		object_id_t objectId, bool *isStep) {
-	Command_t replyId = reply->getCommand();
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	switch(replyId) {
-	case(ModeMessage::REPLY_MODE_REPLY): {
-		result = prepareModeReply(reply, objectId);
-		break;
-	}
-	case(ModeMessage::REPLY_WRONG_MODE_REPLY): {
-		result = prepareWrongModeReply(reply, objectId);
-		break;
-	}
-	case(ModeMessage::REPLY_CANT_REACH_MODE): {
-		result = prepareCantReachModeReply(reply, objectId);
-		break;
-	}
-	case(ModeMessage::REPLY_MODE_INFO):
-		result = INVALID_REPLY;
-		break;
-	default:
-		result = RETURN_FAILED;
-	}
-	return result;
-}
-
-ReturnValue_t CService200ModeCommanding::prepareModeReply(
-		const CommandMessage *reply, object_id_t objectId) {
-	ModePacket modeReplyPacket(objectId,
-			ModeMessage::getMode(reply),
-			ModeMessage::getSubmode(reply));
-	return sendTmPacket(Subservice::REPLY_MODE_REPLY, &modeReplyPacket);
-}
-
-ReturnValue_t CService200ModeCommanding::prepareWrongModeReply(
-		const CommandMessage *reply, object_id_t objectId) {
-	ModePacket wrongModeReply(objectId, ModeMessage::getMode(reply),
-			ModeMessage::getSubmode(reply));
-	return sendTmPacket(Subservice::REPLY_WRONG_MODE_REPLY, &wrongModeReply);
-}
-
-ReturnValue_t CService200ModeCommanding::prepareCantReachModeReply(
-		const CommandMessage *reply, object_id_t objectId) {
-	CantReachModePacket cantReachModePacket(objectId,
-	        ModeMessage::getCantReachModeReason(reply));
-	return sendTmPacket(Subservice::REPLY_CANT_REACH_MODE,
-	        &cantReachModePacket);
-}
--- a/pus/CService200ModeCommanding.h
+++ b/pus/CService200ModeCommanding.h
@ -1,85 +0,0 @@
-#ifndef FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
-#define FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_
-
-#include <framework/tmtcservices/CommandingServiceBase.h>
-
-/**
- * @brief Custom PUS service to set mode of all objects implementing HasModesIF
- *
- * Examples: Device Handlers, Assemblies or Subsystems.
- * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
- * Dissertation Baetz p. 115, 116, 165-167.
- *
- * This is a gateway service. It relays device commands using the software bus.
- * @ingroup pus_services
- */
-class CService200ModeCommanding: public CommandingServiceBase {
-public:
-	static constexpr uint8_t NUMBER_OF_PARALLEL_COMMANDS = 4;
-	static constexpr uint16_t COMMAND_TIMEOUT_SECONDS = 60;
-
-	CService200ModeCommanding(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId);
-	virtual~ CService200ModeCommanding();
-
-protected:
-	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
-	ReturnValue_t isValidSubservice(uint8_t subservice) override;
-	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) override;
-	ReturnValue_t prepareCommand(CommandMessage* message,
-			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-			uint32_t *state, object_id_t objectId) override;
-	ReturnValue_t handleReply(const CommandMessage* reply,
-			Command_t previousCommand, uint32_t *state,
-			CommandMessage* optionalNextCommand, object_id_t objectId,
-			bool *isStep) override;
-
-private:
-	ReturnValue_t checkAndAcquireTargetID(object_id_t* objectIdToSet,
-			const uint8_t* tcData, uint32_t tcDataLen);
-	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
-			MessageQueueId_t* MessageQueueToSet, object_id_t* objectId);
-
-	ReturnValue_t prepareModeReply(const CommandMessage *reply,
-			object_id_t objectId);
-	ReturnValue_t prepareWrongModeReply(const CommandMessage *reply,
-			object_id_t objectId);
-	ReturnValue_t prepareCantReachModeReply(const CommandMessage *reply,
-			object_id_t objectId);
-
-	enum Subservice { //!< [EXPORT] : [COMMENT] Mode Commanding Subservices
-		//!< [EXPORT] : [COMMAND] Command assembly, subsystem or device mode
-		COMMAND_MODE_COMMAND = 1,
-		//!< [EXPORT] : [COMMAND] Command to set the specified Mode,
-		//! regardless of external control flag
-		COMMAND_MODE_COMMAND_FORCED = 2,
-		//!< [EXPORT] : [COMMAND] Read the current mode and
-		//! reply with a REPLY_MODE_REPLY
-		COMMAND_MODE_READ = 3,
-		//!< [EXPORT] : [COMMAND] Trigger an ModeInfo Event.
-		//! This command does NOT have a reply
-		COMMAND_MODE_ANNCOUNCE = 4,
-		//!< [EXPORT] : [COMMAND] Trigger a ModeInfo Event and to send this
-		//! command to every child. This command does NOT have a reply.
-		COMMAND_MODE_ANNOUNCE_RECURSIVELY = 5,
-		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND or CMD_MODE_READ
-		REPLY_MODE_REPLY = 6,
-		//!< [EXPORT] : [REPLY] Reply in case a mode command can't be executed.
-		REPLY_CANT_REACH_MODE = 7,
-		//!< [EXPORT] : [REPLY] Reply to a CMD_MODE_COMMAND, indicating that a
-		//! mode was commanded and a transition started but was aborted,
-		//! the parameters contain the mode that was reached
-		REPLY_WRONG_MODE_REPLY = 8
-	};
-
-	enum modeParameters {
-		MODE_OFF = 0,
-		MODE_ON = 1,
-		MODE_NORMAL = 2,
-		MODE_RAW = 3
-	};
-};
-
-#endif /* FRAMEWORK_PUS_CSERVICE200MODECOMMANDING_H_ */
--- a/pus/Service1TelecommandVerification.cpp
+++ b/pus/Service1TelecommandVerification.cpp
@ -1,100 +0,0 @@
-#include <framework/pus/Service1TelecommandVerification.h>
-#include <framework/pus/servicepackets/Service1Packets.h>
-
-#include <framework/ipc/QueueFactory.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-#include <framework/tmtcpacket/pus/TmPacketStored.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/tmtcservices/AcceptsTelemetryIF.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-
-Service1TelecommandVerification::Service1TelecommandVerification(
-        object_id_t objectId, uint16_t apid, uint8_t serviceId,
-        object_id_t targetDestination):
-        SystemObject(objectId), apid(apid), serviceId(serviceId),
-        targetDestination(targetDestination) {
-	tmQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Service1TelecommandVerification::~Service1TelecommandVerification() {}
-
-MessageQueueId_t Service1TelecommandVerification::getVerificationQueue(){
-	return tmQueue->getId();
-}
-
-
-ReturnValue_t Service1TelecommandVerification::performOperation(
-		uint8_t operationCode){
-	PusVerificationMessage message;
-	ReturnValue_t status = tmQueue->receiveMessage(&message);
-	while(status == HasReturnvaluesIF::RETURN_OK) {
-		status = sendVerificationReport(&message);
-		if(status != HasReturnvaluesIF::RETURN_OK) {
-			return status;
-		}
-		status = tmQueue->receiveMessage(&message);
-	}
-	if (status == MessageQueueIF::EMPTY) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	else {
-		return status;
-	}
-}
-
-
-ReturnValue_t Service1TelecommandVerification::sendVerificationReport(
-		PusVerificationMessage* message) {
-	ReturnValue_t result;
-	if(message->getReportId() % 2 == 0) {
-		result = generateFailureReport(message);
-	} else {
-		result = generateSuccessReport(message);
-	}
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Service1TelecommandVerification::initialize: "
-		        "Sending verification packet failed !" << std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t Service1TelecommandVerification::generateFailureReport(
-        PusVerificationMessage *message) {
-	FailureReport report(
-			message->getReportId(), message->getTcPacketId(),
-			message->getTcSequenceControl(), message->getStep(),
-			message->getErrorCode(), message->getParameter1(),
-			message->getParameter2());
-	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
-	        packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
-			tmQueue->getId());
-	return result;
-}
-
-ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
-        PusVerificationMessage *message) {
-	SuccessReport report(message->getReportId(),message->getTcPacketId(),
-			message->getTcSequenceControl(),message->getStep());
-	TmPacketStored tmPacket(apid, serviceId, message->getReportId(),
-	        packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(tmQueue->getDefaultDestination(),
-			tmQueue->getId());
-	return result;
-}
-
-
-ReturnValue_t Service1TelecommandVerification::initialize() {
-	// Get target object for TC verification messages
-	AcceptsTelemetryIF* funnel = objectManager->
-			get<AcceptsTelemetryIF>(targetDestination);
-	if(funnel == nullptr){
-	    sif::error << "Service1TelecommandVerification::initialize: Specified"
-	            " TM funnel invalid. Make sure it is set up and implements"
-	            " AcceptsTelemetryIF." << std::endl;
-		return ObjectManagerIF::CHILD_INIT_FAILED;
-	}
-	tmQueue->setDefaultDestination(funnel->getReportReceptionQueue());
-	return SystemObject::initialize();
-}
--- a/pus/Service1TelecommandVerification.h
+++ b/pus/Service1TelecommandVerification.h
@ -1,94 +0,0 @@
-#ifndef MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
-#define MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_
-
-#include <framework/objectmanager/SystemObject.h>
-#include <framework/returnvalues/HasReturnvaluesIF.h>
-#include <framework/tasks/ExecutableObjectIF.h>
-#include <framework/tmtcservices/AcceptsVerifyMessageIF.h>
-#include <framework/tmtcservices/PusVerificationReport.h>
-#include <framework/ipc/MessageQueueIF.h>
-
-/**
- * @brief Verify TC acceptance, start, progress and execution.
- *
- * Full Documentation: ECSS-E70-41A p.51
- *
- * The telecommand verification service provides the capability for
- * explicit verification of each distinct stage of execution of a telecommand
- * packet, from on-board acceptance through to completion of execution.
- *
- * Minimum capabilities of this service:
- *
- *  - TM[1,1]: Telecommand Acceptance Report - Success.
- *  - TM[1,2]: Telecommand Acceptance Report - Failure.
- *
- * Additional capabilities of this service:
- *
- *  - TM[1,3]: Telecommand Execution Started Report - Success (Req. 4).
- *  - TM[1,4]: Telecommand Execution Started Report - Failure (Req. 3).
- *  - TM[1,5]: Telecommand Execution Progress Report - Success (Req. 6).
- *  - TM[1,6]: Telecommand Execution Progress Report - Failure (Req. 5).
- *  - TM[1,7]: Telecommand Execution Completed Report - Success (Req. 8).
- *  - TM[1,8]: Telecommand Execution Completed Report - Failure (Req. 7).
- *
- * This Service is not inherited from PUSServiceBase unlike other PUS Services
- * because all services implementing PUSServiceBase use this service to
- * generate verification reports.
- * @ingroup pus_services
- */
-class Service1TelecommandVerification: public AcceptsVerifyMessageIF,
-		public SystemObject,
-		public ExecutableObjectIF,
-		public HasReturnvaluesIF {
-public:
-	static const uint8_t SUBSYSTEM_ID = SUBSYSTEM_ID::PUS_SERVICE_1;
-
-	Service1TelecommandVerification(object_id_t objectId,
-	        uint16_t apid, uint8_t serviceId, object_id_t targetDestination);
-	virtual ~Service1TelecommandVerification();
-
-	/**
-	 *
-	 * @return ID of Verification Queue
-	 */
-	virtual MessageQueueId_t getVerificationQueue();
-
-	/**
-	 * Performs the service periodically as specified in init_mission().
-	 * Triggers the handlePacket function to send TC verification messages
-	 * @param operationCode
-	 * @return
-	 */
-	ReturnValue_t performOperation(uint8_t operationCode = 0) override;
-
-	/**
-	 * Initializes the destination for TC verification messages and initializes
-	 * Service 1 as a system object
-	 * @return
-	 */
-	ReturnValue_t initialize() override;
-private:
-	uint16_t apid = 0;
-	uint8_t serviceId = 0;
-
-	object_id_t targetDestination = objects::NO_OBJECT;
-
-	ReturnValue_t sendVerificationReport(PusVerificationMessage* message);
-	ReturnValue_t generateFailureReport(PusVerificationMessage* message);
-	ReturnValue_t generateSuccessReport(PusVerificationMessage* message);
-
-	uint16_t packetSubCounter = 0;
-
-	MessageQueueIF* tmQueue = nullptr;
-
-	enum class Subservice: uint8_t {
-		VERIFY_ACCEPTANCE_SUCCESS = 1, //!< [EXPORT] : [TM]
-		VERIFY_ACCEPTANCE_FAILED = 2, //!< [EXPORT] : [TM]
-		VERIFY_START_SUCCESS = 3, //!< [EXPORT] : [TM]
-		VERIFY_START_FAILED = 4, //!< [EXPORT] : [TM]
-		VERIFY_STEP_SUCCESS = 5, //!< [EXPORT] : [TM]
-		VERIFY_STEP_FAILED = 6 //!< [EXPORT] : [TM]
-	};
-};
-
-#endif /* MISSION_PUS_SERVICE1TELECOMMANDVERIFICATION_H_ */
--- a/pus/Service2DeviceAccess.cpp
+++ b/pus/Service2DeviceAccess.cpp
@ -1,167 +0,0 @@
-#include <framework/pus/Service2DeviceAccess.h>
-#include <framework/pus/servicepackets/Service2Packets.h>
-
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/storagemanager/StorageManagerIF.h>
-#include <framework/devicehandlers/DeviceHandlerMessage.h>
-#include <framework/serialize/EndianConverter.h>
-#include <framework/action/ActionMessage.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-Service2DeviceAccess::Service2DeviceAccess(object_id_t objectId,
-        uint16_t apid, uint8_t serviceId, uint8_t numberOfParallelCommands,
-        uint16_t commandTimeoutSeconds):
-        CommandingServiceBase(objectId, apid, serviceId,
-	        numberOfParallelCommands, commandTimeoutSeconds) {}
-
-Service2DeviceAccess::~Service2DeviceAccess() {}
-
-
-ReturnValue_t Service2DeviceAccess::isValidSubservice(uint8_t subservice) {
-	switch(static_cast<Subservice>(subservice)){
-	case Subservice::RAW_COMMANDING:
-	case Subservice::TOGGLE_WIRETAPPING:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		sif::error << "Invalid Subservice" << std::endl;
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
-		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
-		MessageQueueId_t* id, object_id_t* objectId) {
-    if(tcDataLen < sizeof(object_id_t)) {
-        return CommandingServiceBase::INVALID_TC;
-    }
-    SerializeAdapter::deSerialize(objectId, &tcData,
-                &tcDataLen, SerializeIF::Endianness::BIG);
-
-	ReturnValue_t result = checkInterfaceAndAcquireMessageQueue(id,objectId);
-	return result;
-}
-
-ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
-		MessageQueueId_t * messageQueueToSet, object_id_t *objectId) {
-	DeviceHandlerIF* possibleTarget =
-			objectManager->get<DeviceHandlerIF>(*objectId);
-	if(possibleTarget == nullptr) {
-		return CommandingServiceBase::INVALID_OBJECT;
-	}
-	*messageQueueToSet = possibleTarget->getCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t Service2DeviceAccess::prepareCommand(CommandMessage* message,
-		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
-		uint32_t* state, object_id_t objectId) {
-	switch(static_cast<Subservice>(subservice)){
-	case Subservice::RAW_COMMANDING: {
-		return prepareRawCommand(dynamic_cast<CommandMessage*>(message),
-				tcData, tcDataLen);
-	}
-	break;
-	case Subservice::TOGGLE_WIRETAPPING: {
-		return prepareWiretappingCommand(dynamic_cast<CommandMessage*>(message),
-				tcData, tcDataLen);
-	}
-	break;
-	default:
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-}
-
-ReturnValue_t Service2DeviceAccess::prepareRawCommand(
-        CommandMessage* messageToSet, const uint8_t *tcData,size_t tcDataLen) {
-	RawCommand RawCommand(tcData,tcDataLen);
-	// store command into the Inter Process Communication Store
-	store_address_t storeAddress;
-	ReturnValue_t result = IPCStore->addData(&storeAddress,
-	        RawCommand.getCommand(), RawCommand.getCommandSize());
-	DeviceHandlerMessage::setDeviceHandlerRawCommandMessage(messageToSet,
-	        storeAddress);
-	return result;
-}
-
-ReturnValue_t Service2DeviceAccess::prepareWiretappingCommand(
-		CommandMessage *messageToSet, const uint8_t *tcData,
-		size_t tcDataLen) {
-	if(tcDataLen != WiretappingToggle::WIRETAPPING_COMMAND_SIZE) {
-		return CommandingServiceBase::INVALID_TC;
-	}
-	WiretappingToggle command;
-	ReturnValue_t result = command.deSerialize(&tcData, &tcDataLen,
-	        SerializeIF::Endianness::BIG);
-	DeviceHandlerMessage::setDeviceHandlerWiretappingMessage(messageToSet,
-			command.getWiretappingMode());
-	return result;
-}
-
-
-ReturnValue_t Service2DeviceAccess::handleReply(const CommandMessage* reply,
-		Command_t previousCommand, uint32_t* state,
-		CommandMessage* optionalNextCommand, object_id_t objectId,
-		bool* isStep) {
-	switch(reply->getCommand()) {
-	case CommandMessage::REPLY_COMMAND_OK:
-		return HasReturnvaluesIF::RETURN_OK;
-	case CommandMessage::REPLY_REJECTED:
-		return reply->getReplyRejectedReason();
-	default:
-		return CommandingServiceBase::INVALID_REPLY;
-	}
-}
-
-// All device handlers set service 2 as default raw receiver for wiretapping
-// so we have to handle those unrequested messages.
-void Service2DeviceAccess::handleUnrequestedReply(CommandMessage* reply) {
-	switch(reply->getCommand()) {
-	case DeviceHandlerMessage::REPLY_RAW_COMMAND:
-		sendWiretappingTm(reply,
-				static_cast<uint8_t>(Subservice::WIRETAPPING_RAW_TC));
-		break;
-	case DeviceHandlerMessage::REPLY_RAW_REPLY:
-		sendWiretappingTm(reply,
-				static_cast<uint8_t>(Subservice::RAW_REPLY));
-		break;
-	default:
-		sif::error << "Unknown message in Service2DeviceAccess::"
-				"handleUnrequestedReply with command ID " <<
-				reply->getCommand() << std::endl;
-		break;
-	}
-	//Must be reached by all cases to clear message
-	reply->clear();
-}
-
-void Service2DeviceAccess::sendWiretappingTm(CommandMessage *reply,
-		uint8_t subservice) {
-	// Raw Wiretapping
-	// Get Address of Data from Message
-	store_address_t storeAddress = DeviceHandlerMessage::getStoreAddress(reply);
-	const uint8_t* data = nullptr;
-	size_t size = 0;
-	ReturnValue_t result = IPCStore->getData(storeAddress, &data, &size);
-	if(result != HasReturnvaluesIF::RETURN_OK){
-		sif::error << "Service2DeviceAccess::sendWiretappingTm: Data Lost in "
-		        "handleUnrequestedReply with failure ID "<< result
-		        << std::endl;
-		return;
-	}
-
-	// Init our dummy packet and correct endianness of object ID before
-	// sending it back.
-	WiretappingPacket TmPacket(DeviceHandlerMessage::getDeviceObjectId(reply),
-	        data);
-	TmPacket.objectId = EndianConverter::convertBigEndian(TmPacket.objectId);
-	sendTmPacket(subservice, TmPacket.data,size, reinterpret_cast<uint8_t*>(
-			&TmPacket.objectId), sizeof(TmPacket.objectId));
-}
-
-MessageQueueId_t Service2DeviceAccess::getDeviceQueue() {
-	return commandQueue->getId();
-}
-
--- a/pus/Service2DeviceAccess.h
+++ b/pus/Service2DeviceAccess.h
@ -1,92 +0,0 @@
-#ifndef FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
-#define FRAMEWORK_PUS_SERVICE2DEVICEACCESS_H_
-
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/devicehandlers/AcceptsDeviceResponsesIF.h>
-#include <framework/tmtcservices/CommandingServiceBase.h>
-
-/**
- * @brief   Raw Commanding and Wiretapping of devices.
- * @details
- * Full Documentation: ECSS-E-ST-70-41C or ECSS-E-70-41A
- * Dissertation Baetz p. 115, 116, 165-167.
- *
- * This service provides the capability to communicate with devices in their
- * native protocols with raw commands through the DeviceHandlerIF.
- *
- * This is a gateway service. It relays device commands to the software bus.
- * This service is very closely tied to the CommandingServiceBase
- * template class.
- *
- * There are 4 adaption points for component implementation through the
- * CommandingServiceBase.
- *
- * This service employs custom subservices exclusively.  This includes a
- * wiretapping subservice to monitor all traffic between target devices and
- * this service.
- *
- *   - TC[2,128]: Raw Commanding
- *   - TC[2,129]: Toggle Wiretapping
- *   - TM[2,130]: Wiretapping Packet TM
- *   - TM[2,131]: Wiretapping Packet TC
- * @ingroup pus_services
- */
-class Service2DeviceAccess : public CommandingServiceBase,
-		public AcceptsDeviceResponsesIF
-{
-public:
-	Service2DeviceAccess(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId, uint8_t numberOfParallelCommands = 4,
-	        uint16_t commandTimeoutSeconds = 60);
-	virtual ~Service2DeviceAccess();
-
-protected:
-	//! CommandingServiceBase (CSB) abstract functions. See CSB documentation.
-	ReturnValue_t isValidSubservice(uint8_t subservice) override;
-	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-	        const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) override;
-	ReturnValue_t prepareCommand(CommandMessage* message, uint8_t subservice,
-	        const uint8_t *tcData, size_t tcDataLen, uint32_t *state,
-	        object_id_t objectId) override;
-	ReturnValue_t handleReply(const CommandMessage* reply,
-				Command_t previousCommand, uint32_t *state,
-				CommandMessage* optionalNextCommand, object_id_t objectId,
-				bool *isStep) override;
-
-	/**
-	 * @brief 	Generates TM packets containing either the TC wiretapping
-	 * 			packets or the TM wiretapping packets.
-	 * Note that for service 2, all telemetry will be treated as an
-	 * unrequested reply regardless of wiretapping mode.
-	 * @param reply
-	 */
-	void handleUnrequestedReply(CommandMessage* reply) override;
-
-	MessageQueueId_t getDeviceQueue() override;
-private:
-	/**
-	 * Generates TM packets for Wiretapping Service
-	 * @param reply
-	 * @param subservice
-	 */
-	void sendWiretappingTm(CommandMessage* reply,uint8_t subservice);
-
-	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
-	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
-
-	ReturnValue_t prepareRawCommand(CommandMessage* messageToSet,
-	        const uint8_t* tcData, size_t tcDataLen);
-	ReturnValue_t prepareWiretappingCommand(CommandMessage* messageToSet,
-	        const uint8_t* tcData, size_t tcDataLen);
-
-	enum class Subservice {
-		RAW_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Command in device native protocol
-		TOGGLE_WIRETAPPING = 129, //!< [EXPORT] : [COMMAND] Toggle wiretapping of raw communication
-		RAW_REPLY = 130, //!< [EXPORT] : [REPLY] Includes wiretapping TM and normal TM raw replies from device
-		WIRETAPPING_RAW_TC = 131 //!< [EXPORT] : [REPLY] Wiretapping packets of commands built by device handler
-	};
-};
-
-
-#endif /* MISSION_PUS_DEVICE2DEVICECOMMANDING_H_ */
--- a/pus/Service5EventReporting.cpp
+++ b/pus/Service5EventReporting.cpp
@ -1,91 +0,0 @@
-#include <framework/pus/Service5EventReporting.h>
-#include <framework/pus/servicepackets/Service5Packets.h>
-
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-#include <framework/events/EventManagerIF.h>
-#include <framework/ipc/QueueFactory.h>
-#include <framework/tmtcpacket/pus/TmPacketStored.h>
-
-
-Service5EventReporting::Service5EventReporting(object_id_t objectId,
-            uint16_t apid, uint8_t serviceId, size_t maxNumberReportsPerCycle):
-		PusServiceBase(objectId, apid, serviceId),
-		maxNumberReportsPerCycle(maxNumberReportsPerCycle) {
-	eventQueue = QueueFactory::instance()->createMessageQueue();
-}
-
-Service5EventReporting::~Service5EventReporting(){}
-
-ReturnValue_t Service5EventReporting::performService() {
-	EventMessage message;
-	ReturnValue_t status = RETURN_OK;
-	for(uint8_t counter = 0;
-	        counter < maxNumberReportsPerCycle;
-	        counter++)
-	{
-	    // Receive messages even if reporting is disabled for now.
-	    status = eventQueue->receiveMessage(&message);
-	    if(status == MessageQueueIF::EMPTY) {
-	        return HasReturnvaluesIF::RETURN_OK;
-	    }
-
-	    if(enableEventReport) {
-	       status = generateEventReport(message);
-	       if(status != HasReturnvaluesIF::RETURN_OK) {
-	           return status;
-	       }
-	    }
-	}
-	sif::debug <<  "Service5EventReporting::generateEventReport:"
-	        " Too many events" << std::endl;
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t Service5EventReporting::generateEventReport(
-		EventMessage message)
-{
-	EventReport report(message.getEventId(),message.getReporter(),
-			message.getParameter1(),message.getParameter2());
-	TmPacketStored tmPacket(PusServiceBase::apid, PusServiceBase::serviceId,
-			message.getSeverity(), packetSubCounter++, &report);
-	ReturnValue_t result = tmPacket.sendPacket(
-	        requestQueue->getDefaultDestination(),requestQueue->getId());
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-		sif::debug << "Service5EventReporting::generateEventReport:"
-		        " Could not send TM packet" << std::endl;
-	}
-	return result;
-}
-
-ReturnValue_t Service5EventReporting::handleRequest(uint8_t subservice) {
-	switch(subservice) {
-	case Subservice::ENABLE: {
-		enableEventReport = true;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	case Subservice::DISABLE: {
-		enableEventReport = false;
-		return HasReturnvaluesIF::RETURN_OK;
-	}
-	default:
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-
-// In addition to the default PUSServiceBase initialization, this service needs
-// to be registered to the event manager to listen for events.
-ReturnValue_t Service5EventReporting::initialize() {
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
-				objects::EVENT_MANAGER);
-	if (manager == NULL) {
-			return RETURN_FAILED;
-	}
-	// register Service 5 as listener for events
-	ReturnValue_t result =  manager->registerListener(eventQueue->getId(),true);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
-	     return result;
-	}
-	return PusServiceBase::initialize();
-}
--- a/pus/Service5EventReporting.h
+++ b/pus/Service5EventReporting.h
@ -1,86 +0,0 @@
-#ifndef FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
-#define FRAMEWORK_PUS_SERVICE5EVENTREPORTING_H_
-
-#include <framework/tmtcservices/PusServiceBase.h>
-#include <framework/events/EventMessage.h>
-
-/**
- * @brief Report on-board events like information or errors
- * @details
- * Full Documentation: ECSS-E70-41A p.79
- * Implements the PusServiceBase template class.
- * Documentation: Dissertation Baetz p.135,136
- *
- * This service provides for the reporting to the service user of information of
- * operational significance.
- *   1. reporting of failures or anomalies detected on-board;
- *   2. reporting of autonomous on-board actions;
- *   3. reporting of normal progress of operations and activities, e.g.
- *   detection of events which are not anomalous (such as payload events),
- *   reaching of predefined steps in an operation. Some reports can combine
- *   more than one of these events.
- *
- * Minimum capabilities of this service:
- *
- * - TM[5,1]: Normal/Progress Report
- * - TM[5,2]: Error/Anomaly Report - Low Severity
- * - TM[5,3]: Error/Anomaly Report - Medium Severity
- * - TM[5,4]: Error/Anomaly Report - High Severity
- *
- * Events can be translated by using translator files located in
- * /config/objects/ and /config/events/. Description to events can be added by
- * adding a comment behind the event definition with [//!<] as leading string
- *
- * Additional capabilities of this service:
- *
- *  - TC[5,5]: Enable Event Report Generation (Req. 6)
- *  - TC[5,6]: Disable Event Report Generation (Req. 5)
- * @author 	R. Mueller
- * @ingroup pus_services
- */
-class Service5EventReporting: public PusServiceBase {
-public:
-
-	Service5EventReporting(object_id_t objectId, uint16_t apid,
-	        uint8_t serviceId, size_t maxNumberReportsPerCycle = 10);
-	virtual ~Service5EventReporting();
-
-	/***
-	* Check for events and generate event reports if required.
-	* @return
-	*/
-	ReturnValue_t performService() override;
-
-	/***
-	 * Turn event generation on or off.
-	 * @return
-	 */
-	ReturnValue_t handleRequest(uint8_t subservice) override;
-
-	/**
-	 * The default PusServiceBase initialize has been overridden but is still
-	 * executed. Registers this service as a listener for events at the
-	 * EventManager.
-	 * @return
-	 */
-	ReturnValue_t initialize() override;
-
-	enum Subservice: uint8_t {
-		NORMAL_REPORT = 1, //!< [EXPORT] : [REPLY] Generate normal report
-		ERROR_LOW_SEVERITY = 2, //!< [EXPORT] : [REPLY] Generate error report with low severity
-		ERROR_MED_SEVERITY = 3, //!< [EXPORT] : [REPLY] Generate error report with medium severity
-		ERROR_HIGH_SEVERITY = 4, //!< [EXPORT] : [REPLY] Generate error report with high severity
-		ENABLE = 5, //!< [EXPORT] : [COMMAND] Enable report generation
-		DISABLE = 6 //!< [EXPORT] : [COMMAND] Disable report generation
-	};
-
-private:
-	uint16_t packetSubCounter = 0;
-	MessageQueueIF* eventQueue = nullptr;
-	bool enableEventReport = true;
-	const uint8_t maxNumberReportsPerCycle;
-
-	ReturnValue_t generateEventReport(EventMessage message);
-};
-
-#endif /* MISSION_PUS_SERVICE5EVENTREPORTING_H_ */
--- a/pus/Service8FunctionManagement.cpp
+++ b/pus/Service8FunctionManagement.cpp
@ -1,142 +0,0 @@
-#include <framework/pus/Service8FunctionManagement.h>
-#include <framework/pus/servicepackets/Service8Packets.h>
-
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/action/HasActionsIF.h>
-#include <framework/devicehandlers/DeviceHandlerIF.h>
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-Service8FunctionManagement::Service8FunctionManagement(object_id_t object_id,
-		uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
-		uint16_t commandTimeoutSeconds):
-		CommandingServiceBase(object_id, apid, serviceId, numParallelCommands,
-		commandTimeoutSeconds) {}
-
-Service8FunctionManagement::~Service8FunctionManagement() {}
-
-
-ReturnValue_t Service8FunctionManagement::isValidSubservice(
-		uint8_t subservice) {
-	switch(static_cast<Subservice>(subservice)) {
-	case Subservice::DIRECT_COMMANDING:
-		return HasReturnvaluesIF::RETURN_OK;
-	default:
-		return AcceptsTelecommandsIF::INVALID_SUBSERVICE;
-	}
-}
-
-ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject(
-		uint8_t subservice, const uint8_t* tcData, size_t tcDataLen,
-		MessageQueueId_t* id, object_id_t* objectId) {
-	if(tcDataLen < sizeof(object_id_t)) {
-		return CommandingServiceBase::INVALID_TC;
-	}
-	SerializeAdapter::deSerialize(objectId, &tcData,
-			&tcDataLen, SerializeIF::Endianness::BIG);
-
-	return checkInterfaceAndAcquireMessageQueue(id,objectId);
-}
-
-ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue(
-		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
-	// check HasActionIF property of target
-	HasActionsIF* possibleTarget = objectManager->get<HasActionsIF>(*objectId);
-	if(possibleTarget == nullptr){
-		return CommandingServiceBase::INVALID_OBJECT;
-	}
-	*messageQueueToSet = possibleTarget->getCommandQueue();
-	return HasReturnvaluesIF::RETURN_OK;
-}
-
-
-ReturnValue_t Service8FunctionManagement::prepareCommand(
-		CommandMessage* message, uint8_t subservice, const uint8_t* tcData,
-		size_t tcDataLen, uint32_t* state, object_id_t objectId) {
-	return prepareDirectCommand(dynamic_cast<CommandMessage*>(message),
-				tcData, tcDataLen);
-}
-
-ReturnValue_t Service8FunctionManagement::prepareDirectCommand(
-		CommandMessage *message, const uint8_t *tcData, size_t tcDataLen) {
-    if(tcDataLen < sizeof(object_id_t) + sizeof(ActionId_t)) {
-        sif::debug << "Service8FunctionManagement::prepareDirectCommand:"
-                << " TC size smaller thant minimum size of direct command."
-                << std::endl;
-        return CommandingServiceBase::INVALID_TC;
-    }
-
-	// Create direct command instance by extracting data from Telecommand
-	DirectCommand command(tcData, tcDataLen);
-
-	// store additional parameters into the IPC Store
-	store_address_t parameterAddress;
-	ReturnValue_t result = IPCStore->addData(&parameterAddress,
-			command.getParameters(),command.getParametersSize());
-
-	// setCommand expects a Command Message, an Action ID and a store adress
-	// pointing to additional parameters
-	ActionMessage::setCommand(message,command.getActionId(),parameterAddress);
-	return result;
-}
-
-
-ReturnValue_t Service8FunctionManagement::handleReply(
-		const CommandMessage* reply, Command_t previousCommand,
-		uint32_t* state, CommandMessage* optionalNextCommand,
-		object_id_t objectId, bool* isStep) {
-	Command_t replyId = reply->getCommand();
-	ReturnValue_t result = HasReturnvaluesIF::RETURN_FAILED;
-	ActionId_t actionId = ActionMessage::getActionId(reply);
-	ReturnValue_t returnCode = ActionMessage::getReturnCode(reply);
-
-	switch(replyId)  {
-	case ActionMessage::COMPLETION_SUCCESS: {
-		DirectReply completionReply(objectId, actionId,returnCode);
-		result = CommandingServiceBase::EXECUTION_COMPLETE;
-		break;
-	}
-	case ActionMessage::STEP_SUCCESS: {
-		*isStep = true;
-		result = HasReturnvaluesIF::RETURN_OK;
-		break;
-	}
-	case ActionMessage::DATA_REPLY: {
-	    result = handleDataReply(reply, objectId, actionId);
-		break;
-	}
-	case ActionMessage::STEP_FAILED:
-		*isStep = true;
-		/*No break, falls through*/
-	case ActionMessage::COMPLETION_FAILED:
-		result = ActionMessage::getReturnCode(reply);
-		break;
-	default:
-		result = INVALID_REPLY;
-	}
-	return result;
-}
-
-ReturnValue_t Service8FunctionManagement::handleDataReply(
-        const CommandMessage* reply, object_id_t objectId,
-        ActionId_t actionId) {
-    store_address_t storeId = ActionMessage::getStoreId(reply);
-    size_t size = 0;
-    const uint8_t * buffer = nullptr;
-    ReturnValue_t result = IPCStore->getData(storeId, &buffer, &size);
-    if(result != RETURN_OK) {
-        sif::error << "Service 8: Could not retrieve data for data reply"
-                << std::endl;
-        return result;
-    }
-    DataReply dataReply(objectId, actionId, buffer, size);
-    result = sendTmPacket(static_cast<uint8_t>(
-            Subservice::DIRECT_COMMANDING_DATA_REPLY), &dataReply);
-
-    auto deletionResult = IPCStore->deleteData(storeId);
-    if(deletionResult != HasReturnvaluesIF::RETURN_OK) {
-        sif::warning << "Service8FunctionManagement::handleReply: Deletion"
-                << " of data in pool failed." << std::endl;
-    }
-    return result;
-}
--- a/pus/Service8FunctionManagement.h
+++ b/pus/Service8FunctionManagement.h
@ -1,67 +0,0 @@
-#ifndef FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
-#define FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_
-
-#include <framework/action/ActionMessage.h>
-#include <framework/tmtcservices/CommandingServiceBase.h>
-
-/**
- * @brief Functional commanding.
- * Full Documentation: ECSS-E-ST-70-41C p.64, p. 451
- * Dissertation Baetz p. 115, 116, 165-167
- *
- * This service provides the capability to perform functions of an
- * application process and provides high-level commanding as opposed to the
- * Raw Access provided by Service 2. Examples for these functions can include
- * control and operation of payload or the AOCS subsystem.
- * This service will be the primary means to control the spacecraft as it is
- * considered safer than the Raw Access provided
- * by Service 2 and is generally sufficient for most tasks.
- *
- * This is a gateway service. It relays device commands using the software bus.
- * This service is very closely tied to the Commanding Service Base template
- * class. There is constant interaction between this Service Base und a
- * subclass like this service.
- *
- * Service Capability:
- * 	 - TC[8,128]: Direct Commanding
- *   - TM[8,130]: Direct Commanding Data Reply
- *
- * @ingroup pus_services
- */
-class Service8FunctionManagement : public CommandingServiceBase
-{
-public:
-	Service8FunctionManagement(object_id_t objectId, uint16_t apid,
-			uint8_t serviceId, uint8_t numParallelCommands = 4,
-			uint16_t commandTimeoutSeconds = 60);
-	virtual ~Service8FunctionManagement();
-
-protected:
-	/* CSB abstract functions implementation . See CSB documentation. */
-	ReturnValue_t isValidSubservice(uint8_t subservice) override;
-	ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
-			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
-			object_id_t *objectId) override;
-	ReturnValue_t prepareCommand(CommandMessage* message,
-				uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
-				uint32_t *state, object_id_t objectId) override;
-	ReturnValue_t handleReply(const CommandMessage* reply,
-				Command_t previousCommand, uint32_t *state,
-				CommandMessage* optionalNextCommand, object_id_t objectId,
-				bool *isStep) override;
-
-private:
-	enum class Subservice {
-		DIRECT_COMMANDING = 128, //!< [EXPORT] : [COMMAND] Functional commanding
-		DIRECT_COMMANDING_DATA_REPLY = 130, //!< [EXPORT] : [REPLY] Data reply
-	};
-
-	ReturnValue_t checkInterfaceAndAcquireMessageQueue(
-	        MessageQueueId_t* messageQueueToSet, object_id_t* objectId);
-	ReturnValue_t prepareDirectCommand(CommandMessage* message,
-			const uint8_t* tcData, size_t tcDataLen);
-	ReturnValue_t handleDataReply(const CommandMessage* reply,
-	        object_id_t objectId, ActionId_t actionId);
-};
-
-#endif /* FRAMEWORK_PUS_SERVICE8FUNCTIONMANAGEMENT_H_ */
--- a/pus/servicepackets/Service1Packets.h
+++ b/pus/servicepackets/Service1Packets.h
@ -1,166 +0,0 @@
-/**
- * @defgroup spacepackets PUS Packet Definitions
- *  This group contains all implemented TM or TM packages that are sent to
- *  or sent by the OBC.They are exported later to display
- *  packet structures in Mission Information Base (MIB).
- */
-
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_
-
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-
-/**
- * @brief 	FailureReport class to serialize a failure report
- * @brief 	Subservice 1, 3, 5, 7
- * @ingroup spacepackets
- */
-class FailureReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 3, 5, 7
-public:
-	FailureReport(uint8_t failureSubtype_, uint16_t packetId_,
-			uint16_t packetSequenceControl_, uint8_t stepNumber_,
-			ReturnValue_t errorCode_, uint32_t errorParameter1_,
-			uint32_t errorParameter2_) :
-			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
-			stepNumber(stepNumber_), errorCode(errorCode_),
-			errorParameter1(errorParameter1_), errorParameter2(errorParameter2_),
-			failureSubtype(failureSubtype_) {}
-
-	/**
-	 * This function is called by the FSFW when calling the tm packet send
-	 * function and supplying the SerializeIF* as parameter
-	 * @param buffer Object content is serialized into the buffer
-	 * @param size
-	 * @param max_size
-	 * @param bigEndian
-	 * @return
-	 */
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-	        size_t maxSize, SerializeIF::Endianness streamEndianness
-	        ) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (failureSubtype == TC_VERIFY::PROGRESS_FAILURE) {
-			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
-			        maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		result = SerializeAdapter::serialize(&errorCode, buffer, size,
-		        maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&errorParameter1, buffer, size,
-		        maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-
-		result = SerializeAdapter::serialize(&errorParameter2, buffer, size,
-		        maxSize, streamEndianness);
-		return result;
-	}
-
-
-	virtual size_t getSerializedSize() const {
-		size_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&packetId);
-		size += sizeof(packetSequenceControl);
-		if(failureSubtype==TC_VERIFY::PROGRESS_FAILURE){
-			size += SerializeAdapter::getSerializedSize(&stepNumber);
-		}
-		size += SerializeAdapter::getSerializedSize(&errorCode);
-		size += SerializeAdapter::getSerializedSize(&errorParameter1);
-		size += SerializeAdapter::getSerializedSize(&errorParameter2);
-		return size;
-	}
-
-	/**
-	 * Deserialization is not allowed for a report.
-	 * @param buffer
-	 * @param size
-	 * @param bigEndian
-	 * @return
-	 */
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
-	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
-	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
-	ReturnValue_t errorCode; //!< [EXPORT] : [COMMENT] Error code which can be looked up in generated error code file
-	uint32_t errorParameter1;
-	uint32_t errorParameter2;
-	const uint8_t failureSubtype; //!< [EXPORT] : [IGNORE]
-};
-
-/**
- * @brief       Subservices 2, 4, 6, 8
- * @ingroup     spacepackets
- */
-class SuccessReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 2, 4, 6, 8
-public:
-	SuccessReport(uint8_t subtype_, uint16_t packetId_,
-			uint16_t packetSequenceControl_,uint8_t stepNumber_) :
-			packetId(packetId_), packetSequenceControl(packetSequenceControl_),
-			stepNumber(stepNumber_), subtype(subtype_) {}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize, SerializeIF::Endianness streamEndianness
-			) const override {
-		ReturnValue_t result = SerializeAdapter::serialize(&packetId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&packetSequenceControl, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		if (subtype == TC_VERIFY::PROGRESS_SUCCESS) {
-			result = SerializeAdapter::serialize(&stepNumber, buffer, size,
-					maxSize, streamEndianness);
-			if (result != HasReturnvaluesIF::RETURN_OK) {
-				return result;
-			}
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		size_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&packetId);
-		size += sizeof(packetSequenceControl);
-		if(subtype == TC_VERIFY::PROGRESS_SUCCESS){
-			size += SerializeAdapter::getSerializedSize(&stepNumber);
-		}
-		return size;
-
-	}
-
-	ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	uint16_t packetId; //!< [EXPORT] : [COMMENT] Packet ID of respective Telecommand
-	uint16_t packetSequenceControl; //!< [EXPORT] : [COMMENT] Packet SSC of respective Telecommand
-	uint8_t stepNumber; //!< [EXPORT] : [OPTIONAL][SUBSERVICE] 6
-	const uint8_t subtype; //!< [EXPORT] : [IGNORE]
-};
-
-#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE1PACKETS_H_ */
--- a/pus/servicepackets/Service200Packets.h
+++ b/pus/servicepackets/Service200Packets.h
@ -1,63 +0,0 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_
-
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/modes/ModeMessage.h>
-#include <framework/serialize/SerializeIF.h>
-
-/**
- * @brief Subservice 1, 2, 3, 4, 5
- * @ingroup spacepackets
- */
-class ModePacket : public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 1, 2, 6
-public:
-
-	ModePacket() {
-		setLinks();
-	}
-
-	ModePacket(object_id_t objectId, Mode_t mode, Submode_t submode) :
-	        objectId(objectId), mode(mode), submode(submode) {
-		setLinks();
-	}
-
-	Mode_t getMode() {
-		return mode.entry;
-	}
-
-	Submode_t getSubmode() {
-		return submode.entry;
-	}
-
-	// Forbid copying, pointers are used.
-	ModePacket(const ModePacket&) = delete;
-	ModePacket& operator=(const ModePacket&) = delete;
-private:
-
-	void setLinks() {
-		setStart(&objectId);
-		objectId.setNext(&mode);
-		mode.setNext(&submode);
-	}
-	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Target or source object
-	SerializeElement<Mode_t> mode; //!< [EXPORT] : [COMMENT] 0: MODE_OFF, 1: MODE_ON, 2: MODE_NORMAL, 3: MODE_RAW
-	SerializeElement<Submode_t> submode; //!< [EXPORT] : [COMMENT] Usually 0, device specific submode possible
-};
-
-/**
- * @brief Subservice 7
- * @ingroup spacepackets
- */
-class CantReachModePacket: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 7
-public:
-    CantReachModePacket(object_id_t objectId, ReturnValue_t reason):
-            objectId(objectId), reason(reason) {
-        setStart(&this->objectId);
-        this->objectId.setNext(&this->reason);
-    }
-
-    SerializeElement<object_id_t> objectId; //!< [EXPORT] : [COMMENT] Reply source object
-	SerializeElement<ReturnValue_t> reason; //!< [EXPORT] : [COMMENT] Reason the mode could not be reached
-};
-
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE200PACKETS_H_ */
--- a/pus/servicepackets/Service2Packets.h
+++ b/pus/servicepackets/Service2Packets.h
@ -1,76 +0,0 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_
-
-#include <framework/action/ActionMessage.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/serviceinterface/ServiceInterfaceStream.h>
-
-/**
- * @brief Subservice 128
- * @ingroup spacepackets
- */
-class RawCommand { //!< [EXPORT] : [SUBSERVICE] 128
-public:
-	RawCommand(const uint8_t* buffer, size_t size) {
-		// Deserialize Adapter to get correct endianness
-		SerializeAdapter::deSerialize(&objectId, &buffer, &size,
-		        SerializeIF::Endianness::BIG);
-		commandBuffer = buffer;
-		// size is decremented by AutoSerializeAdapter,
-		// remaining size is data size
-		dataSize = size;
-	}
-	object_id_t getObjectId() const {
-		return objectId;
-	}
-
-	const uint8_t*  getCommand() {
-		return commandBuffer;
-	}
-
-	size_t getCommandSize() const {
-		return dataSize;
-	}
-private:
-	object_id_t objectId = 0;
-	const uint8_t* commandBuffer = nullptr; //!< [EXPORT] : [MAXSIZE] 256 Bytes
-	size_t dataSize = 0; //!< [EXPORT] : [IGNORE]
-};
-
-
-/**
- * @brief Subservice 129: Command packet to set wiretapping mode
- * @ingroup spacepackets
- */
-class WiretappingToggle: public SerialLinkedListAdapter<SerializeIF>{ //!< [EXPORT] : [SUBSERVICE] 129
-public:
-	static const size_t WIRETAPPING_COMMAND_SIZE = 5;
-	WiretappingToggle(){
-		setStart(&objectId);
-		objectId.setNext(&wiretappingMode);
-	}
-
-	uint8_t getWiretappingMode() const {
-		return wiretappingMode.entry;
-	}
-private:
-	SerializeElement<object_id_t> objectId;
-	SerializeElement<uint8_t> wiretappingMode; //!< [EXPORT] : [INPUT] Mode 0: OFF, Mode 1: RAW
-};
-
-
-/**
- * @brief Subservices 130 and 131: TM packets
- * @ingroup spacepackets
- */
-class WiretappingPacket { //!< [EXPORT] : [SUBSERVICE] 130, 131
-public:
-	object_id_t objectId; //!< [EXPORT] : [COMMENT] Object ID of source object
-	const uint8_t* data; //!< [EXPORT] : [MAXSIZE] Raw Command Max. Size
-	WiretappingPacket(object_id_t objectId, const uint8_t* buffer):
-	    objectId(objectId), data(buffer) {
-	}
-};
-
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE2PACKETS_H_ */
--- a/pus/servicepackets/Service5Packets.h
+++ b/pus/servicepackets/Service5Packets.h
@ -1,76 +0,0 @@
-#ifndef MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
-#define MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_
-
-#include <framework/serialize/SerializeAdapter.h>
-#include <framework/tmtcservices/VerificationCodes.h>
-
-
-/**
- * @brief Subservice 1, 2, 3, 4
- * Structure of Event Report.
- * It consists of:
- *      1. Report ID(RID). This is the Event ID in the FSFW
- *      2. Object ID of the reporter (e.g. subsystem)
- *      2. Parameter 1
- *      3. Parameter 2
- *
- * @ingroup spacepackets
- */
-class EventReport: public SerializeIF { //!< [EXPORT] : [SUBSERVICE] 1, 2, 3, 4
-public:
-
-	EventReport(EventId_t reportId_, object_id_t objectId_, uint32_t parameter1_,
-			uint32_t parameter2_):
-			reportId(reportId_),objectId(objectId_), parameter1(parameter1_),
-			parameter2(parameter2_) {}
-
-	virtual ReturnValue_t serialize(uint8_t** buffer, size_t* size,
-			size_t maxSize,
-			SerializeIF::Endianness streamEndianness) const override
-	{
-		ReturnValue_t result = SerializeAdapter::serialize(&reportId, buffer,
-				size, maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&objectId, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&parameter1, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		result = SerializeAdapter::serialize(&parameter2, buffer, size,
-				maxSize, streamEndianness);
-		if (result != HasReturnvaluesIF::RETURN_OK) {
-			return result;
-		}
-		return result;
-	}
-
-	virtual size_t getSerializedSize() const override {
-		uint32_t size = 0;
-		size += SerializeAdapter::getSerializedSize(&reportId);
-		size += SerializeAdapter::getSerializedSize(&objectId);
-		size += SerializeAdapter::getSerializedSize(&parameter1);
-		size += SerializeAdapter::getSerializedSize(&parameter2);
-		return size;
-
-	}
-
-	virtual ReturnValue_t deSerialize(const uint8_t** buffer, size_t* size,
-	        SerializeIF::Endianness streamEndianness) override {
-		return HasReturnvaluesIF::RETURN_FAILED;
-	}
-private:
-	EventId_t reportId;
-	object_id_t objectId;
-	uint32_t parameter1;
-	uint32_t parameter2;
-};
-
-
-#endif /* MISSION_PUS_SERVICEPACKETS_SERVICE5PACKETS_H_ */
--- a/pus/servicepackets/Service8Packets.h
+++ b/pus/servicepackets/Service8Packets.h
@ -1,121 +0,0 @@
-#ifndef FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
-#define FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_
-
-#include <framework/action/ActionMessage.h>
-#include <framework/objectmanager/SystemObjectIF.h>
-#include <framework/serialize/SerialBufferAdapter.h>
-#include <framework/serialize/SerializeElement.h>
-#include <framework/serialize/SerialLinkedListAdapter.h>
-#include <framework/serialize/SerialFixedArrayListAdapter.h>
-
-
-/**
- * @brief Subservice 128
- * @ingroup spacepackets
- */
-class DirectCommand: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 128
-public:
-
-	DirectCommand(const uint8_t* tcData, size_t size) {
-		SerializeAdapter::deSerialize(&objectId, &tcData, &size,
-		        SerializeIF::Endianness::BIG);
-		SerializeAdapter::deSerialize(&actionId, &tcData, &size,
-		        SerializeIF::Endianness::BIG);
-		parameterBuffer = tcData;
-		parametersSize = size;
-	}
-
-	ActionId_t getActionId() const {
-		return actionId;
-	}
-
-	object_id_t getObjectId() const {
-		return objectId;
-	}
-
-	const uint8_t*  getParameters() {
-		return parameterBuffer;
-	}
-
-	uint32_t getParametersSize() const {
-		return parametersSize;
-	}
-
-private:
-	DirectCommand(const DirectCommand &command);
-	object_id_t objectId;
-	ActionId_t actionId;
-	uint32_t parametersSize; //!< [EXPORT] : [IGNORE]
-	const uint8_t * parameterBuffer; //!< [EXPORT] : [MAXSIZE] 65535 Bytes
-
-};
-
-
-/**
- * @brief Subservice 130
- * Data reply (subservice 130) consists of
- *   1. Target Object ID
- *   2. Action ID
- *   3. Data
- * @ingroup spacepackets
- */
-class DataReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 130
-public:
-	typedef uint16_t typeOfMaxDataSize;
-	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
-	DataReply(object_id_t objectId_, ActionId_t actionId_,
-		const uint8_t * replyDataBuffer_ = NULL, uint16_t replyDataSize_ = 0):
-		objectId(objectId_), actionId(actionId_), replyData(replyDataBuffer_,replyDataSize_){
-		setLinks();
-	}
-
-private:
-	DataReply(const DataReply &reply);
-	void setLinks() {
-		setStart(&objectId);
-		objectId.setNext(&actionId);
-		actionId.setNext(&replyData);
-	}
-	SerializeElement<object_id_t> objectId;
-	SerializeElement<ActionId_t> actionId;
-	SerializeElement<SerialBufferAdapter<uint16_t>> replyData;
-};
-
-
-/**
- * @brief Subservice 132
- * @details
- * Not used yet. Telecommand Verification takes care of this.
- * @ingroup spacepackets
- */
-class DirectReply: public SerialLinkedListAdapter<SerializeIF> { //!< [EXPORT] : [SUBSERVICE] 132
-public:
-	typedef uint16_t typeOfMaxDataSize;
-	static const uint16_t MAX_DATA_LENGTH = sizeof(typeOfMaxDataSize);
-
-	DirectReply(object_id_t objectId_, ActionId_t actionId_, ReturnValue_t returnCode_,
-			bool isStep_ = false, uint8_t step_ = 0):
-			isStep(isStep_), objectId(objectId_), actionId(actionId_),
-			returnCode(returnCode_),step(step_)  {
-		setLinks();
-	}
-private:
-
-	void setLinks() {
-		setStart(&objectId);
-		objectId.setNext(&actionId);
-		actionId.setNext(&returnCode);
-		if(isStep) {
-			returnCode.setNext(&step);
-		}
-	}
-
-	bool isStep; //!< [EXPORT] : [IGNORE]
-	SerializeElement<object_id_t> objectId; //!< [EXPORT] : [IGNORE]
-	SerializeElement<ActionId_t> actionId; //!< [EXPORT] : [IGNORE]
-	SerializeElement<ReturnValue_t> returnCode; //!< [EXPORT] : [IGNORE]
-	SerializeElement<uint8_t> step; //!< [EXPORT] : [OPTIONAL] [IGNORE]
-
-};
-
-#endif /* FRAMEWORK_PUS_SERVICEPACKETS_SERVICE8PACKETS_H_ */
--- a/subsystem/Subsystem.cpp
+++ b/subsystem/Subsystem.cpp
@ -549,7 +549,7 @@ Mode_t Subsystem::getFallbackSequence(Mode_t sequence) {
 	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
 			iter != modeSequences.end(); ++iter) {
 		if (iter.value->first == sequence) {
-			return iter->second.fallbackSequence;
+			return iter->fallbackSequence;
 		}
 	}
 	return -1;
@ -558,7 +558,7 @@ Mode_t Subsystem::getFallbackSequence(Mode_t sequence) {
 bool Subsystem::isFallbackSequence(Mode_t SequenceId) {
 	for (FixedMap<Mode_t, SequenceInfo>::Iterator iter = modeSequences.begin();
 			iter != modeSequences.end(); iter++) {
-		if (iter->second.fallbackSequence == SequenceId) {
+		if (iter->fallbackSequence == SequenceId) {
 			return true;
 		}
 	}
--- a/tasks/PeriodicTaskIF.h
+++ b/tasks/PeriodicTaskIF.h
@ -36,8 +36,7 @@ public:
 	 * to the component.
 	 * @return
 	 */
-	virtual ReturnValue_t addComponent(object_id_t object,
-	        bool setTaskIF = true) {
+	virtual ReturnValue_t addComponent(object_id_t object) {
 	    return HasReturnvaluesIF::RETURN_FAILED;
 	};

--- a/tmtcservices/CommandingServiceBase.cpp
+++ b/tmtcservices/CommandingServiceBase.cpp
@ -8,28 +8,18 @@
 #include <framework/tmtcpacket/pus/TcPacketStored.h>
 #include <framework/tmtcpacket/pus/TmPacketStored.h>

-object_id_t CommandingServiceBase::defaultPacketSource = objects::NO_OBJECT;
-object_id_t CommandingServiceBase::defaultPacketDestination = objects::NO_OBJECT;
-
 CommandingServiceBase::CommandingServiceBase(object_id_t setObjectId,
 		uint16_t apid, uint8_t service, uint8_t numberOfParallelCommands,
-		uint16_t commandTimeoutSeconds, size_t queueDepth) :
+		uint16_t commandTimeoutSeconds, object_id_t setPacketSource,
+		object_id_t setPacketDestination, size_t queueDepth) :
 		SystemObject(setObjectId), apid(apid), service(service),
 		timeoutSeconds(commandTimeoutSeconds),
-		commandMap(numberOfParallelCommands) {
+		commandMap(numberOfParallelCommands), packetSource(setPacketSource),
+		packetDestination(setPacketDestination) {
 	commandQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 	requestQueue = QueueFactory::instance()->createMessageQueue(queueDepth);
 }

-void CommandingServiceBase::setPacketSource(object_id_t packetSource) {
-	this->packetSource = packetSource;
-}
-
-void CommandingServiceBase::setPacketDestination(
-		object_id_t packetDestination) {
-	this->packetDestination = packetDestination;
-}
-

 CommandingServiceBase::~CommandingServiceBase() {
 	QueueFactory::instance()->deleteMessageQueue(commandQueue);
@ -62,18 +52,10 @@ ReturnValue_t CommandingServiceBase::initialize() {
 		return result;
 	}

-	if(packetDestination == objects::NO_OBJECT) {
-	    packetDestination = defaultPacketDestination;
-	}
 	AcceptsTelemetryIF* packetForwarding =
 			objectManager->get<AcceptsTelemetryIF>(packetDestination);
-
-	if(packetSource == objects::NO_OBJECT) {
-	    packetSource = defaultPacketSource;
-	}
 	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
 			packetSource);
-
 	if (packetForwarding == nullptr or distributor == nullptr) {
 	    sif::error << "CommandingServiceBase::intialize: Packet source or "
 	            "packet destination invalid!" << std::endl;
@ -122,17 +104,17 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {


 	// Implemented by child class, specifies what to do with reply.
-	ReturnValue_t result = handleReply(reply, iter->second.command, &iter->second.state,
-			&nextCommand, iter->second.objectId, &isStep);
+	ReturnValue_t result = handleReply(reply, iter->command, &iter->state,
+			&nextCommand, iter->objectId, &isStep);

 	/* If the child implementation does not implement special handling for
-	 * rejected replies (RETURN_FAILED or INVALID_REPLY is returned), a
-	 * failure verification will be generated with the reason as the
-	 * return code and the initial command as failure parameter 1 */
-	if((reply->getCommand() == CommandMessage::REPLY_REJECTED) and
-			(result == RETURN_FAILED or result == INVALID_REPLY)) {
+	 * rejected replies (RETURN_FAILED is returned), a failure verification
+	 * will be generated with the reason as the return code and the initial
+	 * command as failure parameter 1 */
+	if(reply->getCommand() == CommandMessage::REPLY_REJECTED and
+			result == RETURN_FAILED) {
 	    result = reply->getReplyRejectedReason();
-	    failureParameter1 = iter->second.command;
+	    failureParameter1 = iter->command;
 	}

 	switch (result) {
@ -149,14 +131,14 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 	default:
 		if (isStep) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
-					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
-					result, ++iter->second.step, failureParameter1,
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
+					result, ++iter->step, failureParameter1,
 					failureParameter2);
 		} else {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
-					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
+					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
 					result, 0, failureParameter1, failureParameter2);
 		}
 		failureParameter1 = 0;
@ -170,7 +152,7 @@ void CommandingServiceBase::handleCommandMessage(CommandMessage* reply) {
 void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		CommandMapIter iter, CommandMessage* nextCommand,
 		CommandMessage* reply, bool& isStep) {
-	iter->second.command = nextCommand->getCommand();
+	iter->command = nextCommand->getCommand();

 	// In case a new command is to be sent immediately, this is performed here.
 	// If no new command is sent, only analyse reply result by initializing
@ -185,14 +167,14 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		if (isStep and result != NO_STEP_MESSAGE) {
 			verificationReporter.sendSuccessReport(
 					TC_VERIFY::PROGRESS_SUCCESS,
-					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
-					iter->second.tcInfo.tcSequenceControl, ++iter->second.step);
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, ++iter->step);
 		}
 		else {
 			verificationReporter.sendSuccessReport(
 					TC_VERIFY::COMPLETION_SUCCESS,
-					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
-					iter->second.tcInfo.tcSequenceControl, 0);
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, 0);
 			checkAndExecuteFifo(iter);
 		}
 	}
@ -200,16 +182,16 @@ void CommandingServiceBase::handleReplyHandlerResult(ReturnValue_t result,
 		if (isStep) {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::PROGRESS_FAILURE, iter->second.tcInfo.ackFlags,
-					iter->second.tcInfo.tcPacketId,
-					iter->second.tcInfo.tcSequenceControl, sendResult,
-					++iter->second.step, failureParameter1, failureParameter2);
+					TC_VERIFY::PROGRESS_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult,
+					++iter->step, failureParameter1, failureParameter2);
 		} else {
 			nextCommand->clearCommandMessage();
 			verificationReporter.sendFailureReport(
 					TC_VERIFY::COMPLETION_FAILURE,
-					iter->second.tcInfo.ackFlags, iter->second.tcInfo.tcPacketId,
-					iter->second.tcInfo.tcSequenceControl, sendResult, 0,
+					iter->tcInfo.ackFlags, iter->tcInfo.tcPacketId,
+					iter->tcInfo.tcSequenceControl, sendResult, 0,
 					failureParameter1, failureParameter2);
 		}
 		failureParameter1 = 0;
@ -248,7 +230,7 @@ void CommandingServiceBase::handleRequestQueue() {
 		iter = commandMap.find(queue);

 		if (iter != commandMap.end()) {
-			result = iter->second.fifo.insert(address);
+			result = iter->fifo.insert(address);
 			if (result != RETURN_OK) {
 				rejectPacket(TC_VERIFY::START_FAILURE, &packet, OBJECT_BUSY);
 			}
@ -316,11 +298,11 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
        CommandMapIter iter) {
    ReturnValue_t result = RETURN_OK;
    CommandMessage command;
-    iter->second.subservice = storedPacket->getSubService();
-    result = prepareCommand(&command, iter->second.subservice,
+    iter->subservice = storedPacket->getSubService();
+    result = prepareCommand(&command, iter->subservice,
            storedPacket->getApplicationData(),
-            storedPacket->getApplicationDataSize(), &iter->second.state,
-            iter->second.objectId);
+            storedPacket->getApplicationDataSize(), &iter->state,
+            iter->objectId);

    ReturnValue_t sendResult = RETURN_OK;
 	switch (result) {
@ -330,13 +312,13 @@ void CommandingServiceBase::startExecution(TcPacketStored *storedPacket,
 					&command);
 		}
 		if (sendResult == RETURN_OK) {
-			Clock::getUptime(&iter->second.uptimeOfStart);
-			iter->second.step = 0;
-			iter->second.subservice = storedPacket->getSubService();
-			iter->second.command = command.getCommand();
-			iter->second.tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
-			iter->second.tcInfo.tcPacketId = storedPacket->getPacketId();
-			iter->second.tcInfo.tcSequenceControl =
+			Clock::getUptime(&iter->uptimeOfStart);
+			iter->step = 0;
+			iter->subservice = storedPacket->getSubService();
+			iter->command = command.getCommand();
+			iter->tcInfo.ackFlags = storedPacket->getAcknowledgeFlags();
+			iter->tcInfo.tcPacketId = storedPacket->getPacketId();
+			iter->tcInfo.tcSequenceControl =
 					storedPacket->getPacketSequenceControl();
 			acceptPacket(TC_VERIFY::START_SUCCESS, storedPacket);
 		} else {
@ -386,7 +368,7 @@ void CommandingServiceBase::acceptPacket(uint8_t reportId,

 void CommandingServiceBase::checkAndExecuteFifo(CommandMapIter iter) {
 	store_address_t address;
-	if (iter->second.fifo.retrieve(&address) != RETURN_OK) {
+	if (iter->fifo.retrieve(&address) != RETURN_OK) {
 		commandMap.erase(&iter);
 	} else {
 		TcPacketStored newPacket(address);
@ -412,10 +394,10 @@ void CommandingServiceBase::checkTimeout() {
 	Clock::getUptime(&uptime);
 	CommandMapIter iter;
 	for (iter = commandMap.begin(); iter != commandMap.end(); ++iter) {
-		if ((iter->second.uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
+		if ((iter->uptimeOfStart + (timeoutSeconds * 1000)) < uptime) {
 			verificationReporter.sendFailureReport(
-					TC_VERIFY::COMPLETION_FAILURE, iter->second.tcInfo.ackFlags,
-					iter->second.tcInfo.tcPacketId, iter->second.tcInfo.tcSequenceControl,
+					TC_VERIFY::COMPLETION_FAILURE, iter->tcInfo.ackFlags,
+					iter->tcInfo.tcPacketId, iter->tcInfo.tcSequenceControl,
 					TIMEOUT);
 			checkAndExecuteFifo(iter);
 		}
--- a/tmtcservices/CommandingServiceBase.h
+++ b/tmtcservices/CommandingServiceBase.h
@ -15,10 +15,6 @@

 class TcPacketStored;

-namespace Factory{
-void setStaticFrameworkObjectIds();
-}
-
 /**
 * @brief 	This class is the basis for all PUS Services, which have to
 * 			relay Telecommands to software bus.
@ -37,7 +33,6 @@ class CommandingServiceBase: public SystemObject,
 		public AcceptsTelecommandsIF,
 		public ExecutableObjectIF,
 		public HasReturnvaluesIF {
-	friend void (Factory::setStaticFrameworkObjectIds)();
 public:
 	static const uint8_t INTERFACE_ID = CLASS_ID::COMMAND_SERVICE_BASE;
 	static const ReturnValue_t EXECUTION_COMPLETE = MAKE_RETURN_CODE(1);
@ -62,24 +57,10 @@ public:
 	 */
 	CommandingServiceBase(object_id_t setObjectId, uint16_t apid,
 			uint8_t service, uint8_t numberOfParallelCommands,
-			uint16_t commandTimeoutSeconds, size_t queueDepth = 20);
+			uint16_t commandTimeoutSeconds, object_id_t setPacketSource,
+			object_id_t setPacketDestination, size_t queueDepth = 20);
 	virtual ~CommandingServiceBase();

-	/**
-	 * This setter can be used to set the packet source individually instead
-	 * of using the default static framework ID set in the factory.
-	 * This should be called at object initialization and not during run-time!
-	 * @param packetSource
-	 */
-	void setPacketSource(object_id_t packetSource);
-	/**
-	 * This setter can be used to set the packet destination individually
-	 * instead of using the default static framework ID set in the factory.
-	 * This should be called at object initialization and not during run-time!
-	 * @param packetDestination
-	 */
-	void setPacketDestination(object_id_t packetDestination);
-
 	/***
 	 * This is the periodically called function.
 	 * Handle request queue for external commands.
@ -87,7 +68,7 @@ public:
 	 * @param opCode is unused here at the moment
 	 * @return RETURN_OK
 	 */
-	virtual ReturnValue_t performOperation(uint8_t opCode) override;
+	virtual ReturnValue_t performOperation(uint8_t opCode);

 	virtual uint16_t getIdentifier();

@ -108,23 +89,22 @@ public:
 	 */
 	virtual MessageQueueId_t getCommandQueue();

-	virtual ReturnValue_t initialize() override;
+	virtual ReturnValue_t initialize();

 	/**
 	 * Implementation of ExecutableObjectIF function
 	 *
 	 * Used to setup the reference of the task, that executes this component
-	 * @param task Pointer to the taskIF of this task
+	 * @param task_ Pointer to the taskIF of this task
 	 */
-	virtual void setTaskIF(PeriodicTaskIF* task) override;
+	virtual void setTaskIF(PeriodicTaskIF* task_);

 protected:
 	/**
 	 * Check the target subservice
 	 * @param subservice[in]
-	 * @return
-	 * -@c RETURN_OK Subservice valid, continue message handling
-     * -@c INVALID_SUBSERVICE if service is not known, rejects packet.
+	 * @return -@c RETURN_OK on success
+     *         -@c INVALID_SUBSERVICE if service is not known
 	 */
 	virtual ReturnValue_t isValidSubservice(uint8_t subservice) = 0;

@ -137,10 +117,9 @@ protected:
 	 * @param tcDataLen
 	 * @param id MessageQueue ID is stored here
 	 * @param objectId Object ID is extracted and stored here
-	 * @return
-	 * - @c RETURN_OK Cotinue message handling
-	 * - @c RETURN_FAILED Reject the packet and generates a start failure
-	 *      verification
+	 * @return - @c RETURN_OK on success
+	 *         - @c RETURN_FAILED
+	 *         - @c CSB or implementation specific return codes
 	 */
 	virtual ReturnValue_t getMessageQueueAndObject(uint8_t subservice,
 			const uint8_t *tcData, size_t tcDataLen, MessageQueueId_t *id,
@ -159,11 +138,6 @@ protected:
 	 * communication
 	 * @param objectId Target object ID
 	 * @return
-	 * - @c RETURN_OK to generate a verification start message
-	 * - @c EXECUTION_COMPELTE Fire-and-forget command. Generate a completion
-	 *      verification message.
-	 * - @c Anything else rejects the packets and generates a start failure
-	 *      verification.
 	 */
 	virtual ReturnValue_t prepareCommand(CommandMessage* message,
 			uint8_t subservice, const uint8_t *tcData, size_t tcDataLen,
@ -186,12 +160,11 @@ protected:
 	 * @return
 	 * - @c RETURN_OK, @c EXECUTION_COMPLETE or @c NO_STEP_MESSAGE to
 	 *   generate TC verification success
-	 * - @c INVALID_REPLY Calls handleUnrequestedReply
-	 * - Anything else triggers a TC verification failure. If RETURN_FAILED or
-	 * 	 INVALID_REPLY is returned and the command ID is
-	 * 	 CommandMessage::REPLY_REJECTED, a failure verification message with
-	 * 	 the reason as the error parameter and the initial command as
-	 * 	 failure parameter 1 is generated.
+	 * - @c INVALID_REPLY calls handleUnrequestedReply
+	 * - Anything else triggers a TC verification failure. If RETURN_FAILED
+	 *   is returned and the command ID is CommandMessage::REPLY_REJECTED,
+	 *   a failure verification message with the reason as the error parameter
+	 *   and the initial command as failure parameter 1.
 	 */
 	virtual ReturnValue_t handleReply(const CommandMessage* reply,
 			Command_t previousCommand, uint32_t *state,
@ -254,10 +227,9 @@ protected:
 	uint32_t failureParameter1 = 0;
 	uint32_t failureParameter2 = 0;

-	static object_id_t defaultPacketSource;
-	object_id_t packetSource = objects::NO_OBJECT;
-	static object_id_t defaultPacketDestination;
-	object_id_t packetDestination = objects::NO_OBJECT;
+	object_id_t packetSource;
+
+	object_id_t packetDestination;

 	/**
 	 * Pointer to the task which executes this component,
@ -302,6 +274,7 @@ protected:
 	void checkAndExecuteFifo(CommandMapIter iter);

 private:
+
 	/**
 	 * This method handles internal execution of a command,
 	 * once it has been started by @sa{startExecution()} in the request
@ -321,13 +294,10 @@ private:
 	void handleCommandQueue();

 	/**
-	 * @brief       Handler function for request queue
-	 * @details
 	 * Sequence of request queue handling:
 	 * isValidSubservice -> getMessageQueueAndObject -> startExecution
-	 * Generates a Start Success Reports TM[1,3] in subfunction
-	 * @sa{startExecution()} or  a Start Failure Report TM[1,4] by using the
-	 * TC Verification Service.
+	 * Generates Start Success Reports TM[1,3] in subfunction @sa{startExecution()}
+	 * or Start Failure Report TM[1,4] by using the TC Verification Service
 	 */
 	void handleRequestQueue();