Merge remote-tracking branch 'upstream/mueller/master' into mueller/master

action/ActionHelper.cpp

@@ -2,7 +2,7 @@
 #include "HasActionsIF.h"
 
 #include "../ipc/MessageQueueSenderIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../serviceinterface/ServiceInterface.h"
 
 ActionHelper::ActionHelper(HasActionsIF* setOwner,
@@ -25,7 +25,7 @@ ReturnValue_t ActionHelper::handleActionMessage(CommandMessage* command) {
 }
 
 ReturnValue_t ActionHelper::initialize(MessageQueueIF* queueToUse_) {
-    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
     if (ipcStore == nullptr) {
         return HasReturnvaluesIF::RETURN_FAILED;
     }

action/ActionMessage.cpp

@@ -1,7 +1,7 @@
 #include "ActionMessage.h"
 #include "HasActionsIF.h"
 
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../storagemanager/StorageManagerIF.h"
 
 ActionMessage::ActionMessage() {
@@ -69,7 +69,7 @@ void ActionMessage::clear(CommandMessage* message) {
     switch(message->getCommand()) {
     case EXECUTE_ACTION:
     case DATA_REPLY: {
-        StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+        StorageManagerIF *ipcStore = ObjectManager::instance()->get<StorageManagerIF>(
                 objects::IPC_STORE);
         if (ipcStore != NULL) {
             ipcStore->deleteData(getStoreId(message));

action/CommandActionHelper.cpp

@@ -2,7 +2,8 @@
 #include "CommandActionHelper.h"
 #include "CommandsActionsIF.h"
 #include "HasActionsIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
+
+#include "../objectmanager/ObjectManager.h"
 
 CommandActionHelper::CommandActionHelper(CommandsActionsIF *setOwner) :
         owner(setOwner), queueToUse(NULL), ipcStore(
@@ -14,7 +15,7 @@ CommandActionHelper::~CommandActionHelper() {
 
 ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
         ActionId_t actionId, SerializeIF *data) {
-    HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+    HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
     if (receiver == NULL) {
         return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
     }
@@ -40,7 +41,7 @@ ReturnValue_t CommandActionHelper::commandAction(object_id_t commandTo,
 //    if (commandCount != 0) {
 //        return CommandsFunctionsIF::ALREADY_COMMANDING;
 //    }
-    HasActionsIF *receiver = objectManager->get<HasActionsIF>(commandTo);
+    HasActionsIF *receiver = ObjectManager::instance()->get<HasActionsIF>(commandTo);
     if (receiver == NULL) {
         return CommandsActionsIF::OBJECT_HAS_NO_FUNCTIONS;
     }
@@ -66,7 +67,7 @@ ReturnValue_t CommandActionHelper::sendCommand(MessageQueueId_t queueId,
 }
 
 ReturnValue_t CommandActionHelper::initialize() {
-    ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
     if (ipcStore == NULL) {
         return HasReturnvaluesIF::RETURN_FAILED;
     }

controller/ControllerBase.cpp

@@ -3,6 +3,7 @@
 #include "../subsystem/SubsystemBase.h"
 #include "../ipc/QueueFactory.h"
 #include "../action/HasActionsIF.h"
+#include "../objectmanager/ObjectManager.h"
 
 ControllerBase::ControllerBase(object_id_t setObjectId, object_id_t parentId,
         size_t commandQueueDepth) :
@@ -25,7 +26,7 @@ ReturnValue_t ControllerBase::initialize() {
 
     MessageQueueId_t parentQueue = 0;
     if (parentId != objects::NO_OBJECT) {
-        SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+        SubsystemBase *parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
         if (parent == nullptr) {
             return RETURN_FAILED;
         }

datalinklayer/MapPacketExtraction.cpp

@@ -1,10 +1,13 @@
 #include "MapPacketExtraction.h"
+
 #include "../ipc/QueueFactory.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../tmtcpacket/SpacePacketBase.h"
 #include "../tmtcservices/AcceptsTelecommandsIF.h"
 #include "../tmtcservices/TmTcMessage.h"
+#include "../objectmanager/ObjectManager.h"
+
 #include <cstring>
 
 MapPacketExtraction::MapPacketExtraction(uint8_t setMapId,
@@ -131,9 +134,9 @@ void MapPacketExtraction::clearBuffers() {
 }
 
 ReturnValue_t MapPacketExtraction::initialize() {
-	packetStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	packetStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
-	AcceptsTelecommandsIF* distributor = objectManager->get<
+	AcceptsTelecommandsIF* distributor = ObjectManager::instance()->
-			AcceptsTelecommandsIF>(packetDestination);
+	        get<AcceptsTelecommandsIF>(packetDestination);
 	if ((packetStore != NULL) && (distributor != NULL)) {
 		tcQueueId = distributor->getRequestQueue();
 		return RETURN_OK;

datapoollocal/HasLocalDataPoolIF.h

@@ -34,7 +34,8 @@ class LocalPoolObjectBase;
  * can be retrieved using the object manager, provided the target object is a SystemObject.
  * For example, the following line of code can be used to retrieve the interface
  *
- *    HasLocalDataPoolIF* poolIF = objectManager->get<HasLocalDataPoolIF>(objects::SOME_OBJECT);
+ *    HasLocalDataPoolIF* poolIF = ObjectManager::instance()->
+ *             get<HasLocalDataPoolIF>(objects::SOME_OBJECT);
  *    if(poolIF != nullptr) {
  *        doSomething()
  *    }

datapoollocal/LocalDataPoolManager.cpp

@@ -6,6 +6,7 @@
 #include "internal/HasLocalDpIFManagerAttorney.h"
 
 #include "../housekeeping/HousekeepingSetPacket.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../housekeeping/HousekeepingSnapshot.h"
 #include "../housekeeping/AcceptsHkPacketsIF.h"
 #include "../timemanager/CCSDSTime.h"
@@ -52,7 +53,7 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
 	}
 	hkQueue = queueToUse;
 
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
 	if(ipcStore == nullptr) {
 		/* Error, all destinations invalid */
 		printWarningOrError(sif::OutputTypes::OUT_ERROR,
@@ -63,8 +64,8 @@ ReturnValue_t LocalDataPoolManager::initialize(MessageQueueIF* queueToUse) {
 
 
 	if(defaultHkDestination != objects::NO_OBJECT) {
-		AcceptsHkPacketsIF* hkPacketReceiver =
+		AcceptsHkPacketsIF* hkPacketReceiver = ObjectManager::instance()->
-				objectManager->get<AcceptsHkPacketsIF>(defaultHkDestination);
+		        get<AcceptsHkPacketsIF>(defaultHkDestination);
 		if(hkPacketReceiver != nullptr) {
 			hkDestinationId = hkPacketReceiver->getHkQueue();
 		}
@@ -360,8 +361,8 @@ void LocalDataPoolManager::resetHkUpdateResetHelper() {
 ReturnValue_t LocalDataPoolManager::subscribeForPeriodicPacket(sid_t sid,
 		bool enableReporting, float collectionInterval, bool isDiagnostics,
 		object_id_t packetDestination) {
-	AcceptsHkPacketsIF* hkReceiverObject =
+	AcceptsHkPacketsIF* hkReceiverObject = ObjectManager::instance()->
-			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+	        get<AcceptsHkPacketsIF>(packetDestination);
 	if(hkReceiverObject == nullptr) {
 		printWarningOrError(sif::OutputTypes::OUT_WARNING,
 				"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);
@@ -391,7 +392,7 @@ ReturnValue_t LocalDataPoolManager::subscribeForUpdatePacket(sid_t sid,
 		bool isDiagnostics, bool reportingEnabled,
 		object_id_t packetDestination) {
 	AcceptsHkPacketsIF* hkReceiverObject =
-			objectManager->get<AcceptsHkPacketsIF>(packetDestination);
+	        ObjectManager::instance()->get<AcceptsHkPacketsIF>(packetDestination);
 	if(hkReceiverObject == nullptr) {
 		printWarningOrError(sif::OutputTypes::OUT_WARNING,
 				"subscribeForPeriodicPacket", QUEUE_OR_DESTINATION_INVALID);

datapoollocal/LocalPoolDataSetBase.cpp

@@ -3,6 +3,7 @@
 #include "internal/HasLocalDpIFUserAttorney.h"
 
 #include "../serviceinterface/ServiceInterface.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../globalfunctions/bitutility.h"
 #include "../datapoollocal/LocalDataPoolManager.h"
 #include "../housekeeping/PeriodicHousekeepingHelper.h"
@@ -45,7 +46,7 @@ LocalPoolDataSetBase::LocalPoolDataSetBase(HasLocalDataPoolIF *hkOwner,
 LocalPoolDataSetBase::LocalPoolDataSetBase(sid_t sid, PoolVariableIF** registeredVariablesArray,
         const size_t maxNumberOfVariables):
         PoolDataSetBase(registeredVariablesArray, maxNumberOfVariables)  {
-    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(
+    HasLocalDataPoolIF* hkOwner = ObjectManager::instance()->get<HasLocalDataPoolIF>(
             sid.objectId);
     if(hkOwner != nullptr) {
         AccessPoolManagerIF* accessor = HasLocalDpIFUserAttorney::getAccessorHandle(hkOwner);

datapoollocal/LocalPoolObjectBase.cpp

@@ -4,7 +4,7 @@
 #include "HasLocalDataPoolIF.h"
 #include "internal/HasLocalDpIFUserAttorney.h"
 
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 
 
 LocalPoolObjectBase::LocalPoolObjectBase(lp_id_t poolId, HasLocalDataPoolIF* hkOwner,
@@ -43,7 +43,7 @@ LocalPoolObjectBase::LocalPoolObjectBase(object_id_t poolOwner, lp_id_t poolId,
                 "which is the NO_PARAMETER value!\n");
 #endif
     }
-    HasLocalDataPoolIF* hkOwner = objectManager->get<HasLocalDataPoolIF>(poolOwner);
+    HasLocalDataPoolIF* hkOwner = ObjectManager::instance()->get<HasLocalDataPoolIF>(poolOwner);
     if(hkOwner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "LocalPoolVariable: The supplied pool owner did not implement the correct "

devicehandlers/ChildHandlerBase.cpp

@@ -1,6 +1,5 @@
 #include "ChildHandlerBase.h"
 #include "../subsystem/SubsystemBase.h"
-#include "../subsystem/SubsystemBase.h"
 
 ChildHandlerBase::ChildHandlerBase(object_id_t setObjectId,
 		object_id_t deviceCommunication, CookieIF * cookie,
@@ -30,7 +29,7 @@ ReturnValue_t ChildHandlerBase::initialize() {
 	MessageQueueId_t parentQueue = 0;
 
 	if (parentId != objects::NO_OBJECT) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+		SubsystemBase *parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
 		if (parent == NULL) {
 			return RETURN_FAILED;
 		}

devicehandlers/DeviceHandlerBase.cpp

@@ -119,7 +119,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
         return result;
     }
 
-    communicationInterface = objectManager->get<DeviceCommunicationIF>(
+    communicationInterface = ObjectManager::instance()->get<DeviceCommunicationIF>(
             deviceCommunicationId);
     if (communicationInterface == nullptr) {
         printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
@@ -136,7 +136,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
         return result;
     }
 
-    IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    IPCStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
     if (IPCStore == nullptr) {
         printWarningOrError(sif::OutputTypes::OUT_ERROR, "initialize",
                 ObjectManagerIF::CHILD_INIT_FAILED, "IPC Store not set up");
@@ -144,8 +144,8 @@ ReturnValue_t DeviceHandlerBase::initialize() {
     }
 
     if(rawDataReceiverId != objects::NO_OBJECT) {
-        AcceptsDeviceResponsesIF *rawReceiver = objectManager->get<
+        AcceptsDeviceResponsesIF *rawReceiver = ObjectManager::instance()->
-                AcceptsDeviceResponsesIF>(rawDataReceiverId);
+                get<AcceptsDeviceResponsesIF>(rawDataReceiverId);
 
         if (rawReceiver == nullptr) {
             printWarningOrError(sif::OutputTypes::OUT_ERROR,
@@ -164,7 +164,7 @@ ReturnValue_t DeviceHandlerBase::initialize() {
     }
 
     if(powerSwitcherId != objects::NO_OBJECT) {
-        powerSwitcher = objectManager->get<PowerSwitchIF>(powerSwitcherId);
+        powerSwitcher = ObjectManager::instance()->get<PowerSwitchIF>(powerSwitcherId);
         if (powerSwitcher == nullptr) {
             printWarningOrError(sif::OutputTypes::OUT_ERROR,
                     "initialize", ObjectManagerIF::CHILD_INIT_FAILED,

devicehandlers/DeviceHandlerFailureIsolation.cpp

@@ -1,6 +1,7 @@
 #include "DeviceHandlerFailureIsolation.h"
 
 #include "../devicehandlers/DeviceHandlerIF.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../modes/HasModesIF.h"
 #include "../health/HealthTableIF.h"
 #include "../power/Fuse.h"
@@ -175,7 +176,7 @@ ReturnValue_t DeviceHandlerFailureIsolation::initialize() {
 #endif
 		return result;
 	}
-	ConfirmsFailuresIF* power = objectManager->get<ConfirmsFailuresIF>(
+	ConfirmsFailuresIF* power = ObjectManager::instance()->get<ConfirmsFailuresIF>(
 			powerConfirmationId);
 	if (power != nullptr) {
 		powerConfirmation = power->getEventReceptionQueue();

devicehandlers/DeviceHandlerMessage.cpp

@@ -1,5 +1,5 @@
 #include "DeviceHandlerMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 
 store_address_t DeviceHandlerMessage::getStoreAddress(
 		const CommandMessage* message) {
@@ -70,7 +70,7 @@ void DeviceHandlerMessage::clear(CommandMessage* message) {
 	case REPLY_RAW_COMMAND:
 	case REPLY_RAW_REPLY:
 	case REPLY_DIRECT_COMMAND_DATA: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+		StorageManagerIF *ipcStore = ObjectManager::instance()->get<StorageManagerIF>(
 				objects::IPC_STORE);
 		if (ipcStore != nullptr) {
 			ipcStore->deleteData(getStoreAddress(message));

events/EventManager.h

@@ -3,8 +3,7 @@
 
 #include "EventManagerIF.h"
 #include "eventmatching/EventMatchTree.h"
-
+#include "FSFWConfig.h"
-#include <FSFWConfig.h>
 
 #include "../serviceinterface/ServiceInterface.h"
 #include "../objectmanager/SystemObject.h"

events/EventManagerIF.h

@@ -3,7 +3,7 @@
 
 #include "EventMessage.h"
 #include "eventmatching/eventmatching.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../ipc/MessageQueueSenderIF.h"
 #include "../ipc/MessageQueueIF.h"
 #include "../serviceinterface/ServiceInterface.h"
@@ -43,7 +43,7 @@ public:
 	static void triggerEvent(EventMessage* message,
 	        MessageQueueId_t sentFrom = 0) {
 		if (eventmanagerQueue == MessageQueueIF::NO_QUEUE) {
-			EventManagerIF *eventmanager = objectManager->get<EventManagerIF>(
+			EventManagerIF *eventmanager = ObjectManager::instance()->get<EventManagerIF>(
 					objects::EVENT_MANAGER);
 			if (eventmanager == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1

fdir/FailureIsolationBase.cpp

@@ -3,7 +3,7 @@
 #include "../health/HasHealthIF.h"
 #include "../health/HealthMessage.h"
 #include "../ipc/QueueFactory.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 
 FailureIsolationBase::FailureIsolationBase(object_id_t owner,
 		object_id_t parent, uint8_t messageDepth, uint8_t parameterDomainBase) :
@@ -18,7 +18,7 @@ FailureIsolationBase::~FailureIsolationBase() {
 }
 
 ReturnValue_t FailureIsolationBase::initialize() {
-	EventManagerIF* manager = objectManager->get<EventManagerIF>(
+	EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(
 			objects::EVENT_MANAGER);
 	if (manager == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
@@ -36,7 +36,7 @@ ReturnValue_t FailureIsolationBase::initialize() {
 		if (result != HasReturnvaluesIF::RETURN_OK) {
 			return result;
 		}
-		owner = objectManager->get<HasHealthIF>(ownerId);
+		owner = ObjectManager::instance()->get<HasHealthIF>(ownerId);
 		if (owner == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "FailureIsolationBase::intialize: Owner object "
@@ -46,7 +46,7 @@ ReturnValue_t FailureIsolationBase::initialize() {
 		}
 	}
 	if (faultTreeParent != objects::NO_OBJECT) {
-		ConfirmsFailuresIF* parentIF = objectManager->get<ConfirmsFailuresIF>(
+		ConfirmsFailuresIF* parentIF = ObjectManager::instance()->get<ConfirmsFailuresIF>(
 				faultTreeParent);
 		if (parentIF == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1

health/HealthHelper.cpp

@@ -1,5 +1,5 @@
 #include "HealthHelper.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 HealthHelper::HealthHelper(HasHealthIF* owner, object_id_t objectId) :
 		objectId(objectId), owner(owner) {
@@ -37,8 +37,8 @@ void HealthHelper::setParentQueue(MessageQueueId_t parentQueue) {
 }
 
 ReturnValue_t HealthHelper::initialize() {
-	healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
+	healthTable = ObjectManager::instance()->get<HealthTableIF>(objects::HEALTH_TABLE);
-	eventSender = objectManager->get<EventReportingProxyIF>(objectId);
+	eventSender = ObjectManager::instance()->get<EventReportingProxyIF>(objectId);
 
 	if (healthTable == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1

housekeeping/HousekeepingMessage.cpp

@@ -1,6 +1,6 @@
 #include "HousekeepingMessage.h"
 
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 #include <cstring>
 
 HousekeepingMessage::~HousekeepingMessage() {}
@@ -161,7 +161,7 @@ void HousekeepingMessage::clear(CommandMessage* message) {
     case(UPDATE_SNAPSHOT_VARIABLE): {
         store_address_t storeId;
         getHkDataReply(message, &storeId);
-        StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+        StorageManagerIF *ipcStore = ObjectManager::instance()->get<StorageManagerIF>(
                 objects::IPC_STORE);
         if (ipcStore != nullptr) {
             ipcStore->deleteData(storeId);

memory/MemoryHelper.cpp

@@ -2,9 +2,9 @@
 #include "MemoryMessage.h"
 
 #include "../globalfunctions/CRC.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../serialize/EndianConverter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 MemoryHelper::MemoryHelper(HasMemoryIF* workOnThis,
 		MessageQueueIF* useThisQueue):
@@ -187,7 +187,7 @@ ReturnValue_t MemoryHelper::initialize(MessageQueueIF* queueToUse_) {
 }
 
 ReturnValue_t MemoryHelper::initialize() {
-	ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
 	if (ipcStore != nullptr) {
 		return RETURN_OK;
 	} else {

memory/MemoryMessage.cpp

@@ -1,6 +1,6 @@
 #include "MemoryMessage.h"
 
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 
 uint32_t MemoryMessage::getAddress(const CommandMessage* message) {
 	return message->getParameter();
@@ -44,7 +44,7 @@ void MemoryMessage::clear(CommandMessage* message) {
 	switch (message->getCommand()) {
 	case CMD_MEMORY_LOAD:
 	case REPLY_MEMORY_DUMP: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+		StorageManagerIF *ipcStore = ObjectManager::instance()->get<StorageManagerIF>(
 				objects::IPC_STORE);
 		if (ipcStore != NULL) {
 			ipcStore->deleteData(getStoreID(message));

monitoring/LimitViolationReporter.cpp

@@ -1,13 +1,8 @@
-/**
- * @file	LimitViolationReporter.cpp
- * @brief	This file defines the LimitViolationReporter class.
- * @date	17.07.2014
- * @author	baetz
- */
 #include "LimitViolationReporter.h"
 #include "MonitoringIF.h"
 #include "ReceivesMonitoringReportsIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
+
+#include "../objectmanager/ObjectManager.h"
 #include "../serialize/SerializeAdapter.h"
 
 ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF* data) {
@@ -16,7 +11,7 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 		return result;
 	}
 	store_address_t storeId;
-	uint8_t* dataTarget = NULL;
+	uint8_t* dataTarget = nullptr;
 	size_t maxSize = data->getSerializedSize();
 	if (maxSize > MonitoringIF::VIOLATION_REPORT_MAX_SIZE) {
 		return MonitoringIF::INVALID_SIZE;
@@ -38,16 +33,16 @@ ReturnValue_t LimitViolationReporter::sendLimitViolationReport(const SerializeIF
 
 ReturnValue_t LimitViolationReporter::checkClassLoaded() {
 	if (reportQueue == 0) {
-		ReceivesMonitoringReportsIF* receiver = objectManager->get<
+		ReceivesMonitoringReportsIF* receiver = ObjectManager::instance()->get<
 				ReceivesMonitoringReportsIF>(reportingTarget);
-		if (receiver == NULL) {
+		if (receiver == nullptr) {
 			return ObjectManagerIF::NOT_FOUND;
 		}
 		reportQueue = receiver->getCommandQueue();
 	}
-	if (ipcStore == NULL) {
+	if (ipcStore == nullptr) {
-		ipcStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+		ipcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
-		if (ipcStore == NULL) {
+		if (ipcStore == nullptr) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}
 	}
@@ -56,5 +51,5 @@ ReturnValue_t LimitViolationReporter::checkClassLoaded() {
 
 //Lazy initialization.
 MessageQueueId_t LimitViolationReporter::reportQueue = 0;
-StorageManagerIF* LimitViolationReporter::ipcStore = NULL;
+StorageManagerIF* LimitViolationReporter::ipcStore = nullptr;
 object_id_t LimitViolationReporter::reportingTarget = 0;

monitoring/MonitoringMessage.cpp

@@ -1,5 +1,5 @@
 #include "MonitoringMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 
 MonitoringMessage::~MonitoringMessage() {
 }
@@ -25,7 +25,7 @@ void MonitoringMessage::clear(CommandMessage* message) {
 	message->setCommand(CommandMessage::CMD_NONE);
 	switch (message->getCommand()) {
 	case MonitoringMessage::LIMIT_VIOLATION_REPORT: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+		StorageManagerIF *ipcStore = ObjectManager::instance()->get<StorageManagerIF>(
 				objects::IPC_STORE);
 		if (ipcStore != NULL) {
 			ipcStore->deleteData(getStoreId(message));

monitoring/MonitoringMessageContent.h

@@ -5,7 +5,7 @@
 #include "MonitoringIF.h"
 
 #include "../datapoollocal/localPoolDefinitions.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../serialize/SerialBufferAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../serialize/SerializeElement.h"
@@ -71,7 +71,7 @@ private:
 	}
 	bool checkAndSetStamper() {
 		if (timeStamper == nullptr) {
-			timeStamper = objectManager->get<TimeStamperIF>( timeStamperId );
+			timeStamper = ObjectManager::instance()->get<TimeStamperIF>( timeStamperId );
 			if ( timeStamper == nullptr ) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 				sif::error << "MonitoringReportContent::checkAndSetStamper: "

monitoring/TriplexMonitor.h

@@ -5,7 +5,7 @@
 #include "../datapool/PIDReaderList.h"
 #include "../health/HealthTableIF.h"
 #include "../parameters/HasParametersIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 
 
 //SHOULDDO: This is by far not perfect. Could be merged with new Monitor classes. But still, it's over-engineering.
@@ -64,7 +64,7 @@ public:
 		return result;
 	}
 	ReturnValue_t initialize() {
-		healthTable = objectManager->get<HealthTableIF>(objects::HEALTH_TABLE);
+		healthTable = ObjectManager::instance()->get<HealthTableIF>(objects::HEALTH_TABLE);
 		if (healthTable == NULL) {
 			return HasReturnvaluesIF::RETURN_FAILED;
 		}

objectmanager/ObjectManager.cpp

@@ -6,11 +6,23 @@
 #endif
 #include <cstdlib>
 
-ObjectManager::ObjectManager( void (*setProducer)() ):
+ObjectManager* ObjectManager::objManagerInstance = nullptr;
-		produceObjects(setProducer) {
+
-	//There's nothing special to do in the constructor.
+ObjectManager* ObjectManager::instance() {
+    if(objManagerInstance == nullptr) {
+        objManagerInstance = new ObjectManager();
+    }
+    return objManagerInstance;
 }
 
+void ObjectManager::setObjectFactoryFunction(produce_function_t objFactoryFunc, void *factoryArgs) {
+    this->objectFactoryFunction = objFactoryFunc;
+    this->factoryArgs = factoryArgs;
+}
+
+
+ObjectManager::ObjectManager() {}
+
 
 ObjectManager::~ObjectManager() {
 	for (auto const& iter : objectList) {
@@ -28,10 +40,13 @@ ReturnValue_t ObjectManager::insert( object_id_t id, SystemObjectIF* object) {
 		return this->RETURN_OK;
 	} else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "ObjectManager::insert: Object id " << std::hex
+		sif::error << "ObjectManager::insert: Object ID " << std::hex <<
-		           << static_cast<uint32_t>(id) << std::dec
+		        static_cast<uint32_t>(id) << std::dec << " is already in use!" << std::endl;
-				   << " is already in use!" << std::endl;
+		sif::error << "Terminating program" << std::endl;
-		sif::error << "Terminating program." << std::endl;
+#else
+		sif::printError("ObjectManager::insert: Object ID 0x%08x is already in use!\n",
+		        static_cast<unsigned int>(id));
+		sif::printError("Terminating program");
 #endif
 		//This is very severe and difficult to handle in other places.
 		std::exit(INSERTION_FAILED);
@@ -66,12 +81,8 @@ SystemObjectIF* ObjectManager::getSystemObject( object_id_t id ) {
 	}
 }
 
-ObjectManager::ObjectManager() : produceObjects(nullptr) {
-
-}
-
 void ObjectManager::initialize() {
-	if(produceObjects == nullptr) {
+	if(objectFactoryFunction == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "ObjectManager::initialize: Passed produceObjects "
 				"functions is nullptr!" << std::endl;
@@ -80,7 +91,7 @@ void ObjectManager::initialize() {
 #endif
 		return;
 	}
-	this->produceObjects();
+	objectFactoryFunction(factoryArgs);
 	ReturnValue_t result = RETURN_FAILED;
 	uint32_t errorCount = 0;
 	for (auto const& it : objectList) {

objectmanager/ObjectManager.h

@@ -5,6 +5,7 @@
 #include "SystemObjectIF.h"
 #include <map>
 
+
 /**
  * @brief	This class implements a global object manager.
  * @details	This manager handles a list of available objects with system-wide
@@ -19,44 +20,65 @@
  * @author	Bastian Baetz
  */
 class ObjectManager : public ObjectManagerIF {
-private:
-	//comparison?
-	/**
-	 * @brief	This is the map of all initialized objects in the manager.
-	 * @details	Objects in the List must inherit the SystemObjectIF.
-	 */
-	std::map<object_id_t, SystemObjectIF*> objectList;
-protected:
-	SystemObjectIF* getSystemObject( object_id_t id );
-	/**
-	 * @brief	This attribute is initialized with the factory function
-	 * 			that creates new objects.
-	 * @details	The function is called if an object was requested with
-	 * 			getSystemObject, but not found in objectList.
-	 * @param 	The id of the object to be created.
-	 * @return	Returns a pointer to the newly created object or NULL.
-	 */
-	void (*produceObjects)();
 public:
-	/**
+
-	 * @brief	Apart from setting the producer function, nothing special
+    using produce_function_t = void (*) (void* args);
-	 * 			happens in the constructor.
+
-	 * @param setProducer	A pointer to a factory function.
+    /**
-	 */
+     * Returns the single instance of TaskFactory.
-	ObjectManager( void (*produce)() );
+     * The implementation of #instance is found in its subclasses.
-	ObjectManager();
+     * Thus, we choose link-time variability of the  instance.
-	/**
+     */
-	 *	@brief	In the class's destructor, all objects in the list are deleted.
+    static ObjectManager* instance();
-	 */
+
-	// SHOULDDO: If, for some reason, deleting an ObjectManager instance is
+    void setObjectFactoryFunction(produce_function_t prodFunc, void* args);
-	// required, check if this works.
+
-	virtual ~ObjectManager( void );
+    template <typename T> T* get( object_id_t id );
-	ReturnValue_t insert( object_id_t id, SystemObjectIF* object );
+
-	ReturnValue_t remove( object_id_t id );
+    /**
-	void initialize();
+     *  @brief  In the class's destructor, all objects in the list are deleted.
-	void printList();
+     */
+    virtual ~ObjectManager();
+    ReturnValue_t insert(object_id_t id, SystemObjectIF* object) override;
+    ReturnValue_t remove(object_id_t id) override;
+    void initialize() override;
+    void printList() override;
+
+protected:
+    SystemObjectIF* getSystemObject(object_id_t id) override;
+    /**
+     * @brief   This attribute is initialized with the factory function
+     *          that creates new objects.
+     * @details The function is called if an object was requested with
+     *          getSystemObject, but not found in objectList.
+     * @param   The id of the object to be created.
+     * @return  Returns a pointer to the newly created object or NULL.
+     */
+    produce_function_t objectFactoryFunction = nullptr;
+    void* factoryArgs = nullptr;
+
+private:
+    ObjectManager();
+
+    /**
+     * @brief	This is the map of all initialized objects in the manager.
+     * @details	Objects in the List must inherit the SystemObjectIF.
+     */
+    std::map<object_id_t, SystemObjectIF*> objectList;
+    static ObjectManager* objManagerInstance;
 };
 
+/**
+ * @brief   This is the forward declaration of the global objectManager instance.
+ */
+// SHOULDDO: maybe put this in the glob namespace to explicitely mark it global?
+//extern ObjectManagerIF *objectManager;
 
+/*Documentation can be found in the class method declaration above.*/
+template <typename T>
+T* ObjectManager::get( object_id_t id ) {
+    SystemObjectIF* temp = this->getSystemObject(id);
+    return dynamic_cast<T*>(temp);
+}
 
 #endif /* FSFW_OBJECTMANAGER_OBJECTMANAGER_H_ */

objectmanager/ObjectManagerIF.h

@@ -8,11 +8,11 @@
 
 /**
  * @brief	This class provides an interface to the global object manager.
- * @details	This manager handles a list of available objects with system-wide
+ * @details
- * 			relevance, such as device handlers, and TM/TC services. They can be
+ * This manager handles a list of available objects with system-wide relevance, such as device
- * 			inserted, removed and retrieved from the list. On getting the
+ * handlers, and TM/TC services. They can be inserted, removed and retrieved from the list.
- * 			object, the call checks if the object implements the requested
+ * On getting the object, the call checks if the object implements the requested interface.
- * 			interface.
+ * This interface does not specify a getter function because templates can't be used in interfaces.
  * @author	Bastian Baetz
  * @ingroup system_objects
  */
@@ -21,7 +21,8 @@ public:
 	static constexpr uint8_t INTERFACE_ID = CLASS_ID::OBJECT_MANAGER_IF;
 	static constexpr ReturnValue_t INSERTION_FAILED = MAKE_RETURN_CODE( 1 );
 	static constexpr ReturnValue_t NOT_FOUND = MAKE_RETURN_CODE( 2 );
-	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 ); //!< Can be used if the initialization of a SystemObject failed.
+	//!< Can be used if the initialization of a SystemObject failed.
+	static constexpr ReturnValue_t CHILD_INIT_FAILED = MAKE_RETURN_CODE( 3 );
 	static constexpr ReturnValue_t INTERNAL_ERR_REPORTER_UNINIT = MAKE_RETURN_CODE( 4 );
 
 protected:
@@ -49,22 +50,11 @@ public:
 	 * 			@li RETURN_OK in case the object was successfully inserted
 	 */
 	virtual ReturnValue_t insert( object_id_t id, SystemObjectIF* object ) = 0;
-	/**
-	 * @brief	With the get call, interfaces of an object can be retrieved in
-	 * 			a type-safe manner.
-	 * @details With the template-based call, the object list is searched with the
-	 * 			getSystemObject method and afterwards it is checked, if the object
-	 * 			implements the requested interface (with a dynamic_cast).
-	 * @param id	The object id of the requested object.
-	 * @return	The method returns a pointer to an object implementing the
-	 * 			requested interface, or NULL.
-	 */
-	template <typename T> T* get( object_id_t id );
 	/**
 	 * @brief	With this call, an object is removed from the list.
 	 * @param id	The object id of the object to be removed.
-	 * @return	\li NOT_FOUND in case the object was not found
+	 * @return	@li NOT_FOUND in case the object was not found
-	 * 			\li RETURN_OK in case the object was successfully removed
+	 * 			@li RETURN_OK in case the object was successfully removed
 	 */
 	virtual ReturnValue_t remove( object_id_t id ) = 0;
 	virtual void initialize() = 0;
@@ -75,24 +65,4 @@ public:
 	virtual void printList() = 0;
 };
 
-
-/**
- * @brief	This is the forward declaration of the global objectManager instance.
- */
-// SHOULDDO: maybe put this in the glob namespace to explicitely mark it global?
-extern ObjectManagerIF *objectManager;
-
-/*Documentation can be found in the class method declaration above.*/
-template <typename T>
-T* ObjectManagerIF::get( object_id_t id ) {
-	if(objectManager == nullptr) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "ObjectManagerIF: Global object manager has not "
-				"been initialized yet!" << std::endl;
-#endif
-	}
-	SystemObjectIF* temp = this->getSystemObject(id);
-	return dynamic_cast<T*>(temp);
-}
-
 #endif /* OBJECTMANAGERIF_H_ */

objectmanager/SystemObject.cpp

@@ -4,18 +4,14 @@
 
 SystemObject::SystemObject(object_id_t setObjectId, bool doRegister) :
 		objectId(setObjectId), registered(doRegister) {
-	if (registered) {
+    if (registered) {
-	    if(objectManager != nullptr) {
+        ObjectManager::instance()->insert(objectId, this);
-	        objectManager->insert(objectId, this);
+    }
-	    }
-	}
 }
 
 SystemObject::~SystemObject() {
 	if (registered) {
-	    if(objectManager != nullptr) {
+	    ObjectManager::instance()->remove(objectId);
-	        objectManager->remove(objectId);
-	    }
 	}
 }
 

osal/FreeRTOS/FixedTimeslotTask.cpp

@@ -1,6 +1,7 @@
 #include "FixedTimeslotTask.h"
 
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../objectmanager/ObjectManager.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 uint32_t FixedTimeslotTask::deadlineMissedCount = 0;
 const size_t PeriodicTaskIF::MINIMUM_STACK_SIZE = configMINIMAL_STACK_SIZE;
@@ -66,8 +67,7 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
-    ExecutableObjectIF* handler =
+    ExecutableObjectIF* handler = ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
-            objectManager->get<ExecutableObjectIF>(componentId);
 	if (handler != nullptr) {
 		pst.addSlot(componentId, slotTimeMs, executionStep, handler, this);
 		return HasReturnvaluesIF::RETURN_OK;

osal/FreeRTOS/MessageQueue.cpp

@@ -1,7 +1,7 @@
 #include "MessageQueue.h"
 #include "QueueMapManager.h"
-#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManager.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 		maxMessageSize(maxMessageSize) {
@@ -66,7 +66,7 @@ QueueHandle_t MessageQueue::getNativeQueueHandle() {
 ReturnValue_t MessageQueue::handleSendResult(BaseType_t result, bool ignoreFault) {
 	if (result != pdPASS) {
 		if (not ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter = objectManager->
+			InternalErrorReporterIF* internalErrorReporter = ObjectManager::instance()->
 			        get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
 			if (internalErrorReporter != nullptr) {
 				internalErrorReporter->queueMessageNotSent();

osal/FreeRTOS/PeriodicTask.cpp

@@ -1,6 +1,7 @@
 #include "PeriodicTask.h"
 
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../objectmanager/ObjectManager.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../tasks/ExecutableObjectIF.h"
 
 PeriodicTask::PeriodicTask(const char *name, TaskPriority setPriority,
@@ -100,7 +101,7 @@ void PeriodicTask::taskFunctionality() {
 }
 
 ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+	ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1

osal/common/TcpTmTcServer.cpp

@@ -6,7 +6,7 @@
 #include "../../container/SharedRingBuffer.h"
 #include "../../ipc/MessageQueueSenderIF.h"
 #include "../../ipc/MutexGuard.h"
-#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManager.h"
 
 #include "../../serviceinterface/ServiceInterface.h"
 #include "../../tmtcservices/TmTcMessage.h"
@@ -41,7 +41,7 @@ ReturnValue_t TcpTmTcServer::initialize() {
         return result;
     }
 
-    tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+    tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
     if (tcStore == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "TcpTmTcServer::initialize: TC store uninitialized!" << std::endl;
@@ -51,7 +51,7 @@ ReturnValue_t TcpTmTcServer::initialize() {
         return ObjectManagerIF::CHILD_INIT_FAILED;
     }
 
-    tmtcBridge = objectManager->get<TcpTmTcBridge>(tmtcBridgeId);
+    tmtcBridge = ObjectManager::instance()->get<TcpTmTcBridge>(tmtcBridgeId);
 
     int retval = 0;
     struct addrinfo *addrResult = nullptr;

osal/common/UdpTcPollingTask.cpp

@@ -2,7 +2,8 @@
 #include "tcpipHelpers.h"
 #include "../../platform.h"
 #include "../../globalfunctions/arrayprinter.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
+#include "../../objectmanager/ObjectManager.h"
 
 #ifdef PLATFORM_WIN
 #include <winsock2.h>
@@ -116,7 +117,7 @@ ReturnValue_t UdpTcPollingTask::handleSuccessfullTcRead(size_t bytesRead) {
 }
 
 ReturnValue_t UdpTcPollingTask::initialize() {
-    tcStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+    tcStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
     if (tcStore == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "UdpTcPollingTask::initialize: TC store uninitialized!" << std::endl;
@@ -124,7 +125,7 @@ ReturnValue_t UdpTcPollingTask::initialize() {
         return ObjectManagerIF::CHILD_INIT_FAILED;
     }
 
-    tmtcBridge = objectManager->get<UdpTmTcBridge>(tmtcBridgeId);
+    tmtcBridge = ObjectManager::instance()->get<UdpTmTcBridge>(tmtcBridgeId);
     if(tmtcBridge == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "UdpTcPollingTask::initialize: Invalid TMTC bridge object!" <<

osal/host/FixedTimeslotTask.cpp

@@ -1,9 +1,11 @@
 #include "taskHelpers.h"
+
 #include "../../platform.h"
 #include "../../osal/host/FixedTimeslotTask.h"
 #include "../../ipc/MutexFactory.h"
 #include "../../osal/host/Mutex.h"
 #include "../../osal/host/FixedTimeslotTask.h"
+#include "../../objectmanager/ObjectManager.h"
 #include "../../serviceinterface/ServiceInterface.h"
 #include "../../tasks/ExecutableObjectIF.h"
 
@@ -110,7 +112,7 @@ void FixedTimeslotTask::taskFunctionality() {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
         uint32_t slotTimeMs, int8_t executionStep) {
-    ExecutableObjectIF* executableObject = objectManager->
+    ExecutableObjectIF* executableObject = ObjectManager::instance()->
             get<ExecutableObjectIF>(componentId);
     if (executableObject != nullptr) {
         pollingSeqTable.addSlot(componentId, slotTimeMs, executionStep,

osal/host/MessageQueue.cpp

@@ -1,7 +1,8 @@
 #include "MessageQueue.h"
 #include "QueueMapManager.h"
 
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
+#include "../../objectmanager/ObjectManager.h"
 #include "../../ipc/MutexFactory.h"
 #include "../../ipc/MutexGuard.h"
 
@@ -13,8 +14,9 @@ MessageQueue::MessageQueue(size_t messageDepth, size_t maxMessageSize):
 	auto result = QueueMapManager::instance()->addMessageQueue(this, &mqId);
 	if(result != HasReturnvaluesIF::RETURN_OK) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "MessageQueue::MessageQueue:"
+		sif::error << "MessageQueue::MessageQueue: Could not be created" << std::endl;
-		        << " Could not be created" << std::endl;
+#else
+		sif::printError("MessageQueue::MessageQueue: Could not be created\n");
 #endif
 	}
 }
@@ -121,9 +123,8 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
 			QueueMapManager::instance()->getMessageQueue(sendTo));
 	if(targetQueue == nullptr) {
 		if(not ignoreFault) {
-			InternalErrorReporterIF* internalErrorReporter =
+			InternalErrorReporterIF* internalErrorReporter = ObjectManager::instance()->
-					objectManager->get<InternalErrorReporterIF>(
+			        get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
-							objects::INTERNAL_ERROR_REPORTER);
 			if (internalErrorReporter != nullptr) {
 				internalErrorReporter->queueMessageNotSent();
 			}

osal/host/PeriodicTask.cpp

@@ -4,7 +4,8 @@
 
 #include "../../platform.h"
 #include "../../ipc/MutexFactory.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../objectmanager/ObjectManager.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../tasks/ExecutableObjectIF.h"
 
 #include <thread>
@@ -103,7 +104,7 @@ void PeriodicTask::taskFunctionality() {
 }
 
 ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+	ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;

osal/linux/BinarySemaphore.cpp

@@ -1,4 +1,5 @@
 #include "BinarySemaphore.h"
+#include "unixUtility.h"
 #include "../../serviceinterface/ServiceInterfacePrinter.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
@@ -8,154 +9,154 @@
 
 
 BinarySemaphore::BinarySemaphore() {
-	// Using unnamed semaphores for now
+    // Using unnamed semaphores for now
-	initSemaphore();
+    initSemaphore();
 }
 
 BinarySemaphore::~BinarySemaphore() {
-	sem_destroy(&handle);
+    sem_destroy(&handle);
 }
 
 BinarySemaphore::BinarySemaphore(BinarySemaphore&& s) {
-	initSemaphore();
+    initSemaphore();
 }
 
 BinarySemaphore& BinarySemaphore::operator =(
         BinarySemaphore&& s) {
-	initSemaphore();
+    initSemaphore();
-	return * this;
+    return * this;
 }
 
 ReturnValue_t BinarySemaphore::acquire(TimeoutType timeoutType,
-		 uint32_t timeoutMs) {
+        uint32_t timeoutMs) {
-	int result = 0;
+    int result = 0;
-	if(timeoutType == TimeoutType::POLLING) {
+    if(timeoutType == TimeoutType::POLLING) {
-		result = sem_trywait(&handle);
+        result = sem_trywait(&handle);
-	}
+    }
-	else if(timeoutType == TimeoutType::BLOCKING) {
+    else if(timeoutType == TimeoutType::BLOCKING) {
-	    result = sem_wait(&handle);
+        result = sem_wait(&handle);
-	}
+    }
-	else if(timeoutType == TimeoutType::WAITING){
+    else if(timeoutType == TimeoutType::WAITING){
-		timespec timeOut;
+        timespec timeOut;
-		clock_gettime(CLOCK_REALTIME, &timeOut);
+        clock_gettime(CLOCK_REALTIME, &timeOut);
-		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
+        uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
-		nseconds += timeoutMs * 1000000;
+        nseconds += timeoutMs * 1000000;
-		timeOut.tv_sec = nseconds / 1000000000;
+        timeOut.tv_sec = nseconds / 1000000000;
-		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
+        timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
-	    result = sem_timedwait(&handle, &timeOut);
+        result = sem_timedwait(&handle, &timeOut);
-	    if(result != 0 and errno == EINVAL) {
+        if(result != 0 and errno == EINVAL) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+            utility::printUnixErrorGeneric(CLASS_NAME, "acquire", "sem_timedwait");
-	    	sif::debug << "BinarySemaphore::acquire: Invalid time value possible"
+        }
-	    			<< std::endl;
+    }
-#endif
+    if(result == 0) {
-	    }
+        return HasReturnvaluesIF::RETURN_OK;
-	}
+    }
-	if(result == 0) {
-		return HasReturnvaluesIF::RETURN_OK;
-	}
 
-	switch(errno) {
+    switch(errno) {
-	case(EAGAIN):
+    case(EAGAIN):
-		// Operation could not be performed without blocking (for sem_trywait)
+		                // Operation could not be performed without blocking (for sem_trywait)
-	case(ETIMEDOUT):
+    case(ETIMEDOUT): {
-		// Semaphore is 0
+        // Semaphore is 0
-		return SemaphoreIF::SEMAPHORE_TIMEOUT;
+        utility::printUnixErrorGeneric(CLASS_NAME, "acquire", "ETIMEDOUT");
-	case(EINVAL):
+        return SemaphoreIF::SEMAPHORE_TIMEOUT;
-		// Semaphore invalid
+    }
-		return SemaphoreIF::SEMAPHORE_INVALID;
+    case(EINVAL): {
-	case(EINTR):
+        // Semaphore invalid
-		// Call was interrupted by signal handler
+        utility::printUnixErrorGeneric(CLASS_NAME, "acquire", "EINVAL");
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+        return SemaphoreIF::SEMAPHORE_INVALID;
-		sif::debug << "BinarySemaphore::acquire: Signal handler interrupted."
+    }
-				"Code " << strerror(errno) << std::endl;
+    case(EINTR): {
-#endif
+        // Call was interrupted by signal handler
-		/* No break */
+        utility::printUnixErrorGeneric(CLASS_NAME, "acquire", "EINTR");
-	default:
+        return HasReturnvaluesIF::RETURN_FAILED;
-		return HasReturnvaluesIF::RETURN_FAILED;
+    }
-	}
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 ReturnValue_t BinarySemaphore::release() {
-	return BinarySemaphore::release(&this->handle);
+    return BinarySemaphore::release(&this->handle);
 }
 
 ReturnValue_t BinarySemaphore::release(sem_t *handle) {
-	ReturnValue_t countResult = checkCount(handle, 1);
+    ReturnValue_t countResult = checkCount(handle, 1);
-	if(countResult != HasReturnvaluesIF::RETURN_OK) {
+    if(countResult != HasReturnvaluesIF::RETURN_OK) {
-		return countResult;
+        return countResult;
-	}
+    }
 
-	int result = sem_post(handle);
+    int result = sem_post(handle);
-	if(result == 0) {
+    if(result == 0) {
-		return HasReturnvaluesIF::RETURN_OK;
+        return HasReturnvaluesIF::RETURN_OK;
-	}
+    }
 
-	switch(errno) {
+    switch(errno) {
-	case(EINVAL):
+    case(EINVAL): {
-		// Semaphore invalid
+        // Semaphore invalid
-		return SemaphoreIF::SEMAPHORE_INVALID;
+        utility::printUnixErrorGeneric(CLASS_NAME, "release", "EINVAL");
-	case(EOVERFLOW):
+        return SemaphoreIF::SEMAPHORE_INVALID;
-		// SEM_MAX_VALUE overflow. This should never happen
+    }
-	default:
+    case(EOVERFLOW): {
-		return HasReturnvaluesIF::RETURN_FAILED;
+        // SEM_MAX_VALUE overflow. This should never happen
-	}
+        utility::printUnixErrorGeneric(CLASS_NAME, "release", "EOVERFLOW");
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 uint8_t BinarySemaphore::getSemaphoreCounter() const {
-	// And another ugly cast :-D
+    // And another ugly cast :-D
-	return getSemaphoreCounter(const_cast<sem_t*>(&this->handle));
+    return getSemaphoreCounter(const_cast<sem_t*>(&this->handle));
 }
 
 uint8_t BinarySemaphore::getSemaphoreCounter(sem_t *handle) {
-	int value = 0;
+    int value = 0;
-	int result = sem_getvalue(handle, &value);
+    int result = sem_getvalue(handle, &value);
-	if (result == 0) {
+    if (result == 0) {
-		return value;
+        return value;
-	}
+    }
-	else if(result != 0 and errno == EINVAL) {
+    else if(result != 0 and errno == EINVAL) {
-		// Could be called from interrupt, use lightweight printf
+        // Could be called from interrupt, use lightweight printf
-		sif::printError("BinarySemaphore::getSemaphoreCounter: "
+        sif::printError("BinarySemaphore::getSemaphoreCounter: "
-				"Invalid semaphore\n");
+                "Invalid semaphore\n");
-		return 0;
+        return 0;
-	}
+    }
-	else {
+    else {
-		// This should never happen.
+        // This should never happen.
-		return 0;
+        return 0;
-	}
+    }
 }
 
 void BinarySemaphore::initSemaphore(uint8_t initCount) {
-	auto result = sem_init(&handle, true, initCount);
+    auto result = sem_init(&handle, true, initCount);
-	if(result == -1) {
+    if(result == -1) {
-		switch(errno) {
+        switch(errno) {
-		case(EINVAL):
+        case(EINVAL): {
-			// Value exceeds SEM_VALUE_MAX
+            utility::printUnixErrorGeneric(CLASS_NAME, "initSemaphore", "EINVAL");
-		case(ENOSYS): {
+            break;
-			// System does not support process-shared semaphores
+        }
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+        case(ENOSYS): {
-				sif::error << "BinarySemaphore: Init failed with "
+            // System does not support process-shared semaphores
-						<< strerror(errno) << std::endl;
+            utility::printUnixErrorGeneric(CLASS_NAME, "initSemaphore", "ENOSYS");
-#else
+            break;
-				sif::printError("BinarySemaphore: Init failed with %s\n",
+        }
-						strerror(errno));
+        }
-#endif
+    }
-		}
-		}
-	}
 }
 
 ReturnValue_t BinarySemaphore::checkCount(sem_t* handle, uint8_t maxCount) {
-	int value = getSemaphoreCounter(handle);
+    int value = getSemaphoreCounter(handle);
-	if(value >= maxCount) {
+    if(value >= maxCount) {
-		if(maxCount == 1 and value > 1) {
+        if(maxCount == 1 and value > 1) {
-			// Binary Semaphore special case.
+            // Binary Semaphore special case.
-			// This is a config error use lightweight printf is this is called
+            // This is a config error use lightweight printf is this is called
-			// from an interrupt
+            // from an interrupt
-			printf("BinarySemaphore::release: Value of binary semaphore greater"
+            printf("BinarySemaphore::release: Value of binary semaphore greater than 1!\n");
-					" than 1!\n");
+            return HasReturnvaluesIF::RETURN_FAILED;
-			return HasReturnvaluesIF::RETURN_FAILED;
+        }
-		}
+        return SemaphoreIF::SEMAPHORE_NOT_OWNED;
-		return SemaphoreIF::SEMAPHORE_NOT_OWNED;
+    }
-	}
+    return HasReturnvaluesIF::RETURN_OK;
-	return HasReturnvaluesIF::RETURN_OK;
 }

osal/linux/BinarySemaphore.h

@@ -76,6 +76,7 @@ public:
 	static ReturnValue_t checkCount(sem_t* handle, uint8_t maxCount);
 protected:
 	sem_t handle;
+    static constexpr const char* CLASS_NAME = "BinarySemaphore";
 };
 
 #endif /* FRAMEWORK_OSAL_FREERTOS_BINARYSEMPAHORE_H_ */

osal/linux/CMakeLists.txt

@@ -15,6 +15,7 @@ target_sources(${LIB_FSFW_NAME}
 		TaskFactory.cpp
 		Timer.cpp
 		tcpipHelpers.cpp
+		unixUtility.cpp
 )
 
 find_package(Threads REQUIRED)

osal/linux/CountingSemaphore.cpp

@@ -1,58 +1,70 @@
-#include "../../osal/linux/CountingSemaphore.h"
+#include "CountingSemaphore.h"
+#include "unixUtility.h"
+
 #include "../../serviceinterface/ServiceInterface.h"
 
 #include <errno.h>
 
 CountingSemaphore::CountingSemaphore(const uint8_t maxCount, uint8_t initCount):
-		maxCount(maxCount), initCount(initCount) {
+        maxCount(maxCount), initCount(initCount) {
-	if(initCount > maxCount) {
+    if(initCount > maxCount) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "CountingSemaphoreUsingTask: Max count bigger than "
+        sif::warning << "CountingSemaphoreUsingTask: Max count bigger than "
-				"intial cout. Setting initial count to max count." << std::endl;
+                "intial cout. Setting initial count to max count" << std::endl;
+#else
+        sif::printWarning("CountingSemaphoreUsingTask: Max count bigger than "
+                "intial cout. Setting initial count to max count\n");
 #endif
-		initCount = maxCount;
+        initCount = maxCount;
-	}
+    }
 
-	initSemaphore(initCount);
+    initSemaphore(initCount);
 }
 
 CountingSemaphore::CountingSemaphore(CountingSemaphore&& other):
-		maxCount(other.maxCount), initCount(other.initCount) {
+		        maxCount(other.maxCount), initCount(other.initCount) {
-	initSemaphore(initCount);
+    initSemaphore(initCount);
 }
 
 CountingSemaphore& CountingSemaphore::operator =(
-		CountingSemaphore&& other) {
+        CountingSemaphore&& other) {
-	initSemaphore(other.initCount);
+    initSemaphore(other.initCount);
-	return * this;
+    return * this;
 }
 
 ReturnValue_t CountingSemaphore::release() {
-	ReturnValue_t result = checkCount(&handle, maxCount);
+    ReturnValue_t result = checkCount(&handle, maxCount);
-	if(result != HasReturnvaluesIF::RETURN_OK) {
+    if(result != HasReturnvaluesIF::RETURN_OK) {
-		return result;
+        return result;
-	}
+    }
-	return CountingSemaphore::release(&this->handle);
+    return CountingSemaphore::release(&this->handle);
 }
 
 ReturnValue_t CountingSemaphore::release(sem_t* handle) {
-	int result = sem_post(handle);
+    int result = sem_post(handle);
-	if(result == 0) {
+    if(result == 0) {
-		return HasReturnvaluesIF::RETURN_OK;
+        return HasReturnvaluesIF::RETURN_OK;
-	}
+    }
 
-	switch(errno) {
+    switch(errno) {
-	case(EINVAL):
+    case(EINVAL): {
-		// Semaphore invalid
+        // Semaphore invalid
-		return SemaphoreIF::SEMAPHORE_INVALID;
+        utility::printUnixErrorGeneric("CountingSemaphore", "release", "EINVAL");
-	case(EOVERFLOW):
+        return SemaphoreIF::SEMAPHORE_INVALID;
-		// SEM_MAX_VALUE overflow. This should never happen
+    }
-	default:
+
-		return HasReturnvaluesIF::RETURN_FAILED;
+    case(EOVERFLOW): {
-	}
+        // SEM_MAX_VALUE overflow. This should never happen
+        utility::printUnixErrorGeneric("CountingSemaphore", "release", "EOVERFLOW");
+        return SemaphoreIF::SEMAPHORE_INVALID;
+    }
+
+    default:
+        return HasReturnvaluesIF::RETURN_FAILED;
+    }
 }
 
 uint8_t CountingSemaphore::getMaxCount() const {
-	return maxCount;
+    return maxCount;
 }
 

osal/linux/FixedTimeslotTask.cpp

@@ -1,5 +1,7 @@
 #include "FixedTimeslotTask.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+
+#include "../../objectmanager/ObjectManager.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 #include <limits.h>
 
@@ -40,7 +42,7 @@ uint32_t FixedTimeslotTask::getPeriodMs() const {
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
 		uint32_t slotTimeMs, int8_t executionStep) {
 	ExecutableObjectIF* executableObject =
-			objectManager->get<ExecutableObjectIF>(componentId);
+	        ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
 	if (executableObject != nullptr) {
 		pst.addSlot(componentId, slotTimeMs, executionStep,
 				executableObject,this);

osal/linux/MessageQueue.cpp

@@ -1,6 +1,8 @@
 #include "MessageQueue.h"
+#include "unixUtility.h"
+
 #include "../../serviceinterface/ServiceInterface.h"
-#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManager.h"
 
 #include <fstream>
 
@@ -13,7 +15,6 @@
 MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
         id(MessageQueueIF::NO_QUEUE),lastPartner(MessageQueueIF::NO_QUEUE),
         defaultDestination(MessageQueueIF::NO_QUEUE), maxMessageSize(maxMessageSize) {
-    //debug << "MessageQueue::MessageQueue: Creating a queue" << std::endl;
     mq_attr attributes;
     this->id = 0;
     //Set attributes
@@ -30,7 +31,7 @@ MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
     mode_t mode = S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP | S_IROTH | S_IWOTH;
     mqd_t tempId = mq_open(name, oflag, mode, &attributes);
     if (tempId == -1) {
-        handleError(&attributes, messageDepth);
+        handleOpenError(&attributes, messageDepth);
     }
     else {
         //Successful mq_open call
@@ -41,101 +42,14 @@ MessageQueue::MessageQueue(uint32_t messageDepth, size_t maxMessageSize):
 MessageQueue::~MessageQueue() {
     int status = mq_close(this->id);
     if(status != 0){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+        utility::printUnixErrorGeneric(CLASS_NAME, "~MessageQueue", "close");
-        sif::error << "MessageQueue::Destructor: mq_close Failed with status: "
-                << strerror(errno) <<std::endl;
-#endif
     }
     status = mq_unlink(name);
     if(status != 0){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+        utility::printUnixErrorGeneric(CLASS_NAME, "~MessageQueue", "unlink");
-        sif::error << "MessageQueue::Destructor: mq_unlink Failed with status: "
-                << strerror(errno) << std::endl;
-#endif
     }
 }
 
-ReturnValue_t MessageQueue::handleError(mq_attr* attributes,
-        uint32_t messageDepth) {
-    switch(errno) {
-    case(EINVAL): {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "MessageQueue::MessageQueue: Invalid name or attributes"
-                " for message size" << std::endl;
-#endif
-        size_t defaultMqMaxMsg = 0;
-        // Not POSIX conformant, but should work for all UNIX systems.
-        // Just an additional helpful printout :-)
-        if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
-                defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
-            /*
-			See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
-			This happens if the msg_max value is not large enough
-			It is ignored if the executable is run in privileged mode.
-		    Run the unlockRealtime script or grant the mode manually by using:
-			sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
-
-			Persistent solution for session:
-			echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
-
-			Permanent solution:
-			sudo nano /etc/sysctl.conf
-			Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
-			Apply changes with: sudo sysctl -p
-             */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "MessageQueue::MessageQueue: Default MQ size "
-                    << defaultMqMaxMsg << " is too small for requested size "
-                    << messageDepth << std::endl;
-            sif::error << "This error can be fixed by setting the maximum "
-                    "allowed message size higher!" << std::endl;
-#endif
-        }
-        break;
-    }
-    case(EEXIST): {
-        // An error occured during open
-        // We need to distinguish if it is caused by an already created queue
-        // There's another queue with the same name
-        // We unlink the other queue
-        int status = mq_unlink(name);
-        if (status != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "mq_unlink Failed with status: " << strerror(errno)
-													        << std::endl;
-#endif
-        }
-        else {
-            // Successful unlinking, try to open again
-            mqd_t tempId = mq_open(name,
-                    O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
-                    S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
-            if (tempId != -1) {
-                //Successful mq_open
-                this->id = tempId;
-                return HasReturnvaluesIF::RETURN_OK;
-            }
-        }
-        break;
-    }
-
-    default: {
-        // Failed either the first time or the second time
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "MessageQueue::MessageQueue: Creating Queue " << name
-                << " failed with status: " << strerror(errno) << std::endl;
-#else
-        sif::printError("MessageQueue::MessageQueue: Creating Queue %s"
-                " failed with status: %s\n", name, strerror(errno));
-#endif
-    }
-    }
-    return HasReturnvaluesIF::RETURN_FAILED;
-
-
-
-}
-
 ReturnValue_t MessageQueue::sendMessage(MessageQueueId_t sendTo,
         MessageQueueMessageIF* message, bool ignoreFault) {
     return sendMessageFrom(sendTo, message, this->getId(), false);
@@ -204,7 +118,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
             return MessageQueueIF::EMPTY;
         case EBADF: {
             //mqdes doesn't represent a valid queue open for reading.
-            return handleRecvError("EBADF");
+            utility::printUnixErrorGeneric(CLASS_NAME, "receiveMessage", "EBADF");
+            break;
         }
         case EINVAL: {
             /*
@@ -216,7 +131,8 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
              *   queue, and the QNX extended option MQ_READBUF_DYNAMIC hasn't
              *   been set in the queue's mq_flags.
              */
-            return handleRecvError("EINVAL");
+            utility::printUnixErrorGeneric(CLASS_NAME, "receiveMessage", "EINVAL");
+            break;
         }
         case EMSGSIZE: {
             /*
@@ -228,23 +144,25 @@ ReturnValue_t MessageQueue::receiveMessage(MessageQueueMessageIF* message) {
              *   given msg_len is too short for the message that would have
              *   been received.
              */
-            return handleRecvError("EMSGSIZE");
+            utility::printUnixErrorGeneric(CLASS_NAME, "receiveMessage", "EMSGSIZE");
+            break;
         }
 
         case EINTR: {
             //The operation was interrupted by a signal.
-            return handleRecvError("EINTR");
+            utility::printUnixErrorGeneric(CLASS_NAME, "receiveMessage", "EINTR");
+            break;
         }
         case ETIMEDOUT: {
             //The operation was interrupted by a signal.
-            return handleRecvError("ETIMEDOUT");
+            utility::printUnixErrorGeneric(CLASS_NAME, "receiveMessage", "ETIMEDOUT");
+            break;
         }
 
         default:
-
             return HasReturnvaluesIF::RETURN_FAILED;
         }
-
+        return HasReturnvaluesIF::RETURN_FAILED;
     }
 }
 
@@ -259,29 +177,27 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
         switch(errno){
         case EBADF:
             //mqdes doesn't represent a valid message queue.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+            utility::printUnixErrorGeneric(CLASS_NAME, "flush", "EBADF");
-            sif::error << "MessageQueue::flush configuration error, "
+            break;
-            "called flush with an invalid queue ID" << std::endl;
-#endif
             /*NO BREAK*/
         case EINVAL:
             //mq_attr is NULL
+            utility::printUnixErrorGeneric(CLASS_NAME, "flush", "EINVAL");
+            break;
         default:
             return HasReturnvaluesIF::RETURN_FAILED;
         }
+        return HasReturnvaluesIF::RETURN_FAILED;
     }
     *count = attrib.mq_curmsgs;
     attrib.mq_curmsgs = 0;
     status = mq_setattr(id,&attrib,NULL);
     if(status != 0){
-        switch(errno){
+        switch(errno) {
         case EBADF:
             //mqdes doesn't represent a valid message queue.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+            utility::printUnixErrorGeneric(CLASS_NAME, "flush", "EBADF");
-            sif::error << "MessageQueue::flush configuration error, "
+            break;
-            "called flush with an invalid queue ID" << std::endl;
-#endif
-            /*NO BREAK*/
         case EINVAL:
             /*
              * This value indicates one of the following:
@@ -290,9 +206,12 @@ ReturnValue_t MessageQueue::flush(uint32_t* count) {
              *    mq_flags includes a 0 in the MQ_MULT_NOTIFY bit. Once
              *    MQ_MULT_NOTIFY has been turned on, it may never be turned off.
              */
+            utility::printUnixErrorGeneric(CLASS_NAME, "flush", "EINVAL");
+            break;
         default:
             return HasReturnvaluesIF::RETURN_FAILED;
         }
+        return HasReturnvaluesIF::RETURN_FAILED;
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
@@ -333,8 +252,9 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         bool ignoreFault) {
     if(message == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-        sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is "
+        sif::error << "MessageQueue::sendMessageFromMessageQueue: Message is nullptr!" << std::endl;
-                "nullptr!" << std::endl;
+#else
+        sif::printError("MessageQueue::sendMessageFromMessageQueue: Message is nullptr!\n");
 #endif
         return HasReturnvaluesIF::RETURN_FAILED;
     }
@@ -347,9 +267,8 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
     //TODO: Check if we're in ISR.
     if (result != 0) {
         if(!ignoreFault){
-            InternalErrorReporterIF* internalErrorReporter =
+            InternalErrorReporterIF* internalErrorReporter = ObjectManager::instance()->
-                    objectManager->get<InternalErrorReporterIF>(
+                    get<InternalErrorReporterIF>(objects::INTERNAL_ERROR_REPORTER);
-                            objects::INTERNAL_ERROR_REPORTER);
             if (internalErrorReporter != NULL) {
                 internalErrorReporter->queueMessageNotSent();
             }
@@ -363,17 +282,20 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
         case EBADF: {
             //mq_des doesn't represent a valid message queue descriptor,
             //or mq_des wasn't opened for writing.
+
+            utility::printUnixErrorGeneric(CLASS_NAME, "sendMessageFromMessageQueue", "EBADF");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-            sif::error << "MessageQueue::sendMessage: Configuration error, MQ"
+            sif::warning << "mq_send to: " << sendTo << " sent from "
-                    << " destination invalid."  << std::endl;
+                    << sentFrom << "failed" << std::endl;
-            sif::error << strerror(errno) << " in "
+#else
-                    <<"mq_send to: " << sendTo << " sent from "
+            sif::printWarning("mq_send to: %d sent from %d failed\n", sendTo, sentFrom);
-                    << sentFrom << std::endl;
 #endif
             return DESTINATION_INVALID;
         }
         case EINTR:
             //The call was interrupted by a signal.
+            utility::printUnixErrorGeneric(CLASS_NAME, "sendMessageFromMessageQueue", "EINTR");
+            break;
         case EINVAL:
             /*
              * This value indicates one of the following:
@@ -384,36 +306,87 @@ ReturnValue_t MessageQueue::sendMessageFromMessageQueue(MessageQueueId_t sendTo,
              * - MQ_PRIO_RESTRICT is set in the mq_attr of mq_des, and
              *   msg_prio is greater than the priority of the calling process.
              */
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+            utility::printUnixErrorGeneric(CLASS_NAME, "sendMessageFromMessageQueue", "EINVAL");
-            sif::error << "MessageQueue::sendMessage: Configuration error "
+            break;
-            << strerror(errno) << " in mq_send" << std::endl;
-#endif
-            /*NO BREAK*/
         case EMSGSIZE:
             // The msg_len is greater than the msgsize associated with
             //the specified queue.
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+            utility::printUnixErrorGeneric(CLASS_NAME, "sendMessageFromMessageQueue", "EMSGSIZE");
-            sif::error << "MessageQueue::sendMessage: Size error [" <<
+            break;
-            strerror(errno) << "] in mq_send" << std::endl;
-#endif
-            /*NO BREAK*/
         default:
             return HasReturnvaluesIF::RETURN_FAILED;
         }
+        return HasReturnvaluesIF::RETURN_FAILED;
     }
     return HasReturnvaluesIF::RETURN_OK;
 }
 
-ReturnValue_t MessageQueue::handleRecvError(const char * const failString) {
+ReturnValue_t MessageQueue::handleOpenError(mq_attr* attributes,
-    if(failString == nullptr) {
+        uint32_t messageDepth) {
-        return HasReturnvaluesIF::RETURN_FAILED;
+    switch(errno) {
-    }
+    case(EINVAL): {
+        utility::printUnixErrorGeneric(CLASS_NAME, "MessageQueue", "EINVAL");
+        size_t defaultMqMaxMsg = 0;
+        // Not POSIX conformant, but should work for all UNIX systems.
+        // Just an additional helpful printout :-)
+        if(std::ifstream("/proc/sys/fs/mqueue/msg_max",std::ios::in) >>
+                defaultMqMaxMsg and defaultMqMaxMsg < messageDepth) {
+            /*
+            See: https://www.man7.org/linux/man-pages/man3/mq_open.3.html
+            This happens if the msg_max value is not large enough
+            It is ignored if the executable is run in privileged mode.
+            Run the unlockRealtime script or grant the mode manually by using:
+            sudo setcap 'CAP_SYS_RESOURCE=+ep' <pathToBinary>
+
+            Persistent solution for session:
+            echo <newMsgMax> | sudo tee /proc/sys/fs/mqueue/msg_max
+
+            Permanent solution:
+            sudo nano /etc/sysctl.conf
+            Append at end: fs/mqueue/msg_max = <newMsgMaxLen>
+            Apply changes with: sudo sysctl -p
+             */
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-    sif::error << "MessageQueue::receiveMessage: " << failString << " error "
+            sif::error << "MessageQueue::MessageQueue: Default MQ size " << defaultMqMaxMsg <<
-            << strerror(errno)  << std::endl;
+                    " is too small for requested size " << messageDepth << std::endl;
+            sif::error << "This error can be fixed by setting the maximum "
+                    "allowed message size higher!" << std::endl;
 #else
-    sif::printError("MessageQueue::receiveMessage: %s error %s\n", failString,
+            sif::printError("MessageQueue::MessageQueue: Default MQ size %d is too small for"
-            strerror(errno));
+                    "requested size %d\n");
+            sif::printError("This error can be fixes by setting the maximum allowed"
+                    "message size higher!\n");
 #endif
+        }
+        break;
+    }
+    case(EEXIST): {
+        // An error occured during open.
+        // We need to distinguish if it is caused by an already created queue
+        // There's another queue with the same name
+        // We unlink the other queue
+        int status = mq_unlink(name);
+        if (status != 0) {
+            utility::printUnixErrorGeneric(CLASS_NAME, "MessageQueue", "EEXIST");
+        }
+        else {
+            // Successful unlinking, try to open again
+            mqd_t tempId = mq_open(name,
+                    O_NONBLOCK | O_RDWR | O_CREAT | O_EXCL,
+                    S_IWUSR | S_IREAD | S_IWGRP | S_IRGRP, attributes);
+            if (tempId != -1) {
+                //Successful mq_open
+                this->id = tempId;
+                return HasReturnvaluesIF::RETURN_OK;
+            }
+        }
+        break;
+    }
+
+    default: {
+        // Failed either the first time or the second time
+        utility::printUnixErrorGeneric(CLASS_NAME, "MessageQueue", "Unknown");
+    }
+    }
     return HasReturnvaluesIF::RETURN_FAILED;
 }

osal/linux/MessageQueue.h

@@ -181,8 +181,8 @@ private:
 	static uint16_t queueCounter;
 	const size_t maxMessageSize;
 
-	ReturnValue_t handleError(mq_attr* attributes, uint32_t messageDepth);
+	static constexpr const char* CLASS_NAME = "MessageQueue";
-	ReturnValue_t handleRecvError(const char* const failString);
+	ReturnValue_t handleOpenError(mq_attr* attributes, uint32_t messageDepth);
 };
 
 #endif /* FSFW_OSAL_LINUX_MESSAGEQUEUE_H_ */

osal/linux/Mutex.cpp

@@ -1,43 +1,34 @@
 #include "Mutex.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "unixUtility.h"
+
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../timemanager/Clock.h"
 
-uint8_t Mutex::count = 0;
-
-
 #include <cstring>
 #include <errno.h>
 
+uint8_t Mutex::count = 0;
+
 Mutex::Mutex() {
 	pthread_mutexattr_t mutexAttr;
 	int status = pthread_mutexattr_init(&mutexAttr);
 	if (status != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+	    utility::printUnixErrorGeneric("Mutex", "Mutex", "pthread_mutexattr_init");
-		sif::error << "Mutex: Attribute init failed with: " << strerror(status) << std::endl;
-#endif
 	}
 	status = pthread_mutexattr_setprotocol(&mutexAttr, PTHREAD_PRIO_INHERIT);
 	if (status != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+	    utility::printUnixErrorGeneric("Mutex", "Mutex", "pthread_mutexattr_setprotocol");
-		sif::error << "Mutex: Attribute set PRIO_INHERIT failed with: " << strerror(status)
-				<< std::endl;
-#endif
 	}
 	status = pthread_mutex_init(&mutex, &mutexAttr);
 	if (status != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+	    utility::printUnixErrorGeneric("Mutex", "Mutex", "pthread_mutex_init");
-		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
-				<< ", " << " failed with " << strerror(status) << std::endl;
-#endif
 	}
 	// After a mutex attributes object has been used to initialize one or more
 	// mutexes, any function affecting the attributes object
 	// (including destruction) shall not affect any previously initialized mutexes.
 	status = pthread_mutexattr_destroy(&mutexAttr);
 	if (status != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+	    utility::printUnixErrorGeneric("Mutex", "Mutex", "pthread_mutexattr_destroy");
-		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
-#endif
 	}
 }
 

osal/linux/PeriodicPosixTask.cpp

@@ -1,8 +1,11 @@
-#include "../../tasks/ExecutableObjectIF.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include <errno.h>
 #include "PeriodicPosixTask.h"
 
+#include "../../objectmanager/ObjectManager.h"
+#include "../../tasks/ExecutableObjectIF.h"
+#include "../../serviceinterface/ServiceInterface.h"
+
+#include <errno.h>
+
 PeriodicPosixTask::PeriodicPosixTask(const char* name_, int priority_,
 		size_t stackSize_, uint32_t period_, void(deadlineMissedFunc_)()):
 		PosixThread(name_, priority_, stackSize_), objectList(), started(false),
@@ -22,12 +25,15 @@ void* PeriodicPosixTask::taskEntryPoint(void* arg) {
 }
 
 ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object) {
-	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
+	ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "PeriodicTask::addComponent: Invalid object. Make sure"
 				<< " it implements ExecutableObjectIF!" << std::endl;
+#else
+		sif::printError("PeriodicTask::addComponent: Invalid object. Make sure it"
+		        "implements ExecutableObjectIF!\n");
 #endif
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
@@ -44,9 +50,6 @@ ReturnValue_t PeriodicPosixTask::sleepFor(uint32_t ms) {
 
 ReturnValue_t PeriodicPosixTask::startTask(void) {
 	started = true;
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-	//sif::info << stackSize << std::endl;
-#endif
 	PosixThread::createTask(&taskEntryPoint,this);
 	return HasReturnvaluesIF::RETURN_OK;
 }

osal/linux/PosixThread.cpp

@@ -1,4 +1,5 @@
 #include "PosixThread.h"
+#include "unixUtility.h"
 
 #include "../../serviceinterface/ServiceInterface.h"
 
@@ -6,263 +7,240 @@
 #include <errno.h>
 
 PosixThread::PosixThread(const char* name_, int priority_, size_t stackSize_):
-		thread(0), priority(priority_), stackSize(stackSize_) {
+        thread(0), priority(priority_), stackSize(stackSize_) {
     name[0] = '\0';
     std::strncat(name, name_, PTHREAD_MAX_NAMELEN - 1);
 }
 
 PosixThread::~PosixThread() {
-	//No deletion and no free of Stack Pointer
+    //No deletion and no free of Stack Pointer
 }
 
 ReturnValue_t PosixThread::sleep(uint64_t ns) {
-	//TODO sleep might be better with timer instead of sleep()
+    //TODO sleep might be better with timer instead of sleep()
-	timespec time;
+    timespec time;
-	time.tv_sec = ns/1000000000;
+    time.tv_sec = ns/1000000000;
-	time.tv_nsec = ns - time.tv_sec*1e9;
+    time.tv_nsec = ns - time.tv_sec*1e9;
 
-	//Remaining Time is not set here
+    //Remaining Time is not set here
-	int status = nanosleep(&time,NULL);
+    int status = nanosleep(&time,NULL);
-	if(status != 0){
+    if(status != 0){
-		switch(errno){
+        switch(errno){
-		case EINTR:
+        case EINTR:
-			//The nanosleep() function was interrupted by a signal.
+            //The nanosleep() function was interrupted by a signal.
-			return HasReturnvaluesIF::RETURN_FAILED;
+            return HasReturnvaluesIF::RETURN_FAILED;
-		case EINVAL:
+        case EINVAL:
-			//The rqtp argument specified a nanosecond value less than zero or
+            //The rqtp argument specified a nanosecond value less than zero or
-			// greater than or equal to 1000 million.
+            // greater than or equal to 1000 million.
-			return HasReturnvaluesIF::RETURN_FAILED;
+            return HasReturnvaluesIF::RETURN_FAILED;
-		default:
+        default:
-			return HasReturnvaluesIF::RETURN_FAILED;
+            return HasReturnvaluesIF::RETURN_FAILED;
-		}
+        }
 
-	}
+    }
-	return HasReturnvaluesIF::RETURN_OK;
+    return HasReturnvaluesIF::RETURN_OK;
 }
 
 void PosixThread::suspend() {
-	//Wait for SIGUSR1
+    //Wait for SIGUSR1
-	int caughtSig = 0;
+    int caughtSig = 0;
-	sigset_t waitSignal;
+    sigset_t waitSignal;
-	sigemptyset(&waitSignal);
+    sigemptyset(&waitSignal);
-	sigaddset(&waitSignal, SIGUSR1);
+    sigaddset(&waitSignal, SIGUSR1);
-	sigwait(&waitSignal, &caughtSig);
+    sigwait(&waitSignal, &caughtSig);
-	if (caughtSig != SIGUSR1) {
+    if (caughtSig != SIGUSR1) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "FixedTimeslotTask: Unknown Signal received: " <<
+        sif::error << "FixedTimeslotTask::suspend: Unknown Signal received: " << caughtSig <<
-				caughtSig << std::endl;
+                std::endl;
+#else
+        sif::printError("FixedTimeslotTask::suspend: Unknown Signal received: %d\n", caughtSig);
 #endif
-	}
+    }
 }
 
 void PosixThread::resume(){
-	/* Signal the thread to start. Makes sense to call kill to start or? ;)
+    /* Signal the thread to start. Makes sense to call kill to start or? ;)
-	 *
+     *
-	*	According to Posix raise(signal) will call pthread_kill(pthread_self(), sig),
+     *	According to Posix raise(signal) will call pthread_kill(pthread_self(), sig),
-	*	but as the call must be done from the thread itsself this is not possible here
+     *	but as the call must be done from the thread itsself this is not possible here
-	*/
+     */
-	pthread_kill(thread,SIGUSR1);
+    pthread_kill(thread,SIGUSR1);
 }
 
 bool PosixThread::delayUntil(uint64_t* const prevoiusWakeTime_ms,
-		const uint64_t delayTime_ms) {
+        const uint64_t delayTime_ms) {
-	uint64_t nextTimeToWake_ms;
+    uint64_t nextTimeToWake_ms;
-	bool shouldDelay = false;
+    bool shouldDelay = false;
-	//Get current Time
+    //Get current Time
-	const uint64_t currentTime_ms = getCurrentMonotonicTimeMs();
+    const uint64_t currentTime_ms = getCurrentMonotonicTimeMs();
-	/* Generate the tick time at which the task wants to wake. */
+    /* Generate the tick time at which the task wants to wake. */
-	nextTimeToWake_ms = (*prevoiusWakeTime_ms) + delayTime_ms;
+    nextTimeToWake_ms = (*prevoiusWakeTime_ms) + delayTime_ms;
 
-	if (currentTime_ms < *prevoiusWakeTime_ms) {
+    if (currentTime_ms < *prevoiusWakeTime_ms) {
-		/* The tick count has overflowed since this function was
+        /* The tick count has overflowed since this function was
 		lasted called.  In this case the only time we should ever
 		actually delay is if the wake time has also overflowed,
 		and the wake time is greater than the tick time. When this
 		is the case it is as if neither time had overflowed. */
-		if ((nextTimeToWake_ms < *prevoiusWakeTime_ms)
+        if ((nextTimeToWake_ms < *prevoiusWakeTime_ms)
-				&& (nextTimeToWake_ms > currentTime_ms)) {
+                && (nextTimeToWake_ms > currentTime_ms)) {
-			shouldDelay = true;
+            shouldDelay = true;
-		}
+        }
-	} else {
+    } else {
-		/* The tick time has not overflowed. In this case we will
+        /* The tick time has not overflowed. In this case we will
 		delay if either the wake time has overflowed, and/or the
 		tick time is less than the wake time. */
-		if ((nextTimeToWake_ms < *prevoiusWakeTime_ms)
+        if ((nextTimeToWake_ms < *prevoiusWakeTime_ms)
-				|| (nextTimeToWake_ms > currentTime_ms)) {
+                || (nextTimeToWake_ms > currentTime_ms)) {
-			shouldDelay = true;
+            shouldDelay = true;
-		}
+        }
-	}
+    }
 
-	/* Update the wake time ready for the next call. */
+    /* Update the wake time ready for the next call. */
 
-	(*prevoiusWakeTime_ms) =  nextTimeToWake_ms;
+    (*prevoiusWakeTime_ms) =  nextTimeToWake_ms;
 
-	if (shouldDelay) {
+    if (shouldDelay) {
-		uint64_t sleepTime = nextTimeToWake_ms - currentTime_ms;
+        uint64_t sleepTime = nextTimeToWake_ms - currentTime_ms;
-		PosixThread::sleep(sleepTime * 1000000ull);
+        PosixThread::sleep(sleepTime * 1000000ull);
-		return true;
+        return true;
-	}
+    }
-	//We are shifting the time in case the deadline was missed like rtems
+    //We are shifting the time in case the deadline was missed like rtems
-	(*prevoiusWakeTime_ms) = currentTime_ms;
+    (*prevoiusWakeTime_ms) = currentTime_ms;
-	return false;
+    return false;
 
 }
 
 
 uint64_t PosixThread::getCurrentMonotonicTimeMs(){
-	timespec timeNow;
+    timespec timeNow;
-	clock_gettime(CLOCK_MONOTONIC_RAW, &timeNow);
+    clock_gettime(CLOCK_MONOTONIC_RAW, &timeNow);
-	uint64_t currentTime_ms = (uint64_t) timeNow.tv_sec * 1000
+    uint64_t currentTime_ms = (uint64_t) timeNow.tv_sec * 1000
-				+ timeNow.tv_nsec / 1000000;
+            + timeNow.tv_nsec / 1000000;
 
-	return currentTime_ms;
+    return currentTime_ms;
 }
 
 
 void PosixThread::createTask(void* (*fnc_)(void*), void* arg_) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-	//sif::debug << "PosixThread::createTask" << std::endl;
+    //sif::debug << "PosixThread::createTask" << std::endl;
 #endif
-	/*
+    /*
-	 * The attr argument points to a pthread_attr_t structure whose contents
+     * The attr argument points to a pthread_attr_t structure whose contents
        are used at thread creation time to determine attributes for the new
        thread; this structure is initialized using pthread_attr_init(3) and
        related functions.  If attr is NULL, then the thread is created with
        default attributes.
-	 */
+     */
-	pthread_attr_t attributes;
+    pthread_attr_t attributes;
-	int status = pthread_attr_init(&attributes);
+    int status = pthread_attr_init(&attributes);
-	if(status != 0){
+    if(status != 0){
+        utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_attr_init");
+    }
+    void* stackPointer;
+    status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
+    if(status != 0) {
+        if(errno == ENOMEM) {
+            size_t stackMb = stackSize/10e6;
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "Posix Thread attribute init failed with: " <<
+            sif::error << "PosixThread::createTask: Insufficient memory for"
-				strerror(status) << std::endl;
+                    " the requested " << stackMb << " MB" << std::endl;
-#endif
-	}
-	void* stackPointer;
-	status = posix_memalign(&stackPointer, sysconf(_SC_PAGESIZE), stackSize);
-	if(status != 0){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PosixThread::createTask: Stack init failed with: " <<
-				strerror(status) << std::endl;
-#endif
-		if(errno == ENOMEM) {
-			size_t stackMb = stackSize/10e6;
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "PosixThread::createTask: Insufficient memory for"
-					" the requested " << stackMb << " MB" << std::endl;
 #else
-			sif::printError("PosixThread::createTask: Insufficient memory for "
+            sif::printError("PosixThread::createTask: Insufficient memory for "
-					"the requested %lu MB\n", static_cast<unsigned long>(stackMb));
+                    "the requested %lu MB\n", static_cast<unsigned long>(stackMb));
 #endif
-		}
+            utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "ENOMEM");
-		else if(errno == EINVAL) {
+        }
+        else if(errno == EINVAL) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-			sif::error << "PosixThread::createTask: Wrong alignment argument!"
+            sif::error << "PosixThread::createTask: Wrong alignment argument!"
-					<< std::endl;
+                    << std::endl;
 #else
-			sif::printError("PosixThread::createTask: "
+            sif::printError("PosixThread::createTask: Wrong alignment argument!\n");
-					"Wrong alignment argument!\n");
 #endif
-		}
+            utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "EINVAL");
-		return;
+        }
-	}
+        return;
+    }
 
-	status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
+    status = pthread_attr_setstack(&attributes, stackPointer, stackSize);
-	if(status != 0){
+    if(status != 0) {
+        utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_attr_setstack");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PosixThread::createTask: pthread_attr_setstack "
+        sif::warning << "Make sure the specified stack size is valid and is "
-				" failed with: " << strerror(status) <<  std::endl;
+                "larger than the minimum allowed stack size." << std::endl;
-		sif::error << "Make sure the specified stack size is valid and is "
+#else
-				"larger than the minimum allowed stack size." << std::endl;
+        sif::printWarning("Make sure the specified stack size is valid and is "
+                "larger than the minimum allowed stack size.\n");
 #endif
-	}
+    }
 
-	status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
+    status = pthread_attr_setinheritsched(&attributes, PTHREAD_EXPLICIT_SCHED);
-	if(status != 0){
+    if(status != 0){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+        utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_attr_setinheritsched");
-			sif::error << "Posix Thread attribute setinheritsched failed with: " <<
+    }
-					strerror(status) << std::endl;
-#endif
-	}
 #ifndef FSFW_USE_REALTIME_FOR_LINUX
 #error "Please define FSFW_USE_REALTIME_FOR_LINUX with either 0 or 1"
 #endif
 #if FSFW_USE_REALTIME_FOR_LINUX == 1
-	// FIFO -> This needs root privileges for the process
+    // FIFO -> This needs root privileges for the process
-	status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
+    status = pthread_attr_setschedpolicy(&attributes,SCHED_FIFO);
-	if(status != 0){
+    if(status != 0){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+        utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_attr_setschedpolicy");
-		sif::error << "Posix Thread attribute schedule policy failed with: " <<
+    }
-				strerror(status) << std::endl;
-#endif
-	}
 
-	sched_param scheduleParams;
+    sched_param scheduleParams;
-	scheduleParams.__sched_priority = priority;
+    scheduleParams.__sched_priority = priority;
-	status = pthread_attr_setschedparam(&attributes, &scheduleParams);
+    status = pthread_attr_setschedparam(&attributes, &scheduleParams);
-	if(status != 0){
+    if(status != 0){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+        utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_attr_setschedparam");
-		sif::error << "Posix Thread attribute schedule params failed with: " <<
+    }
-				strerror(status) << std::endl;
 #endif
-	}
+    //Set Signal Mask for suspend until startTask is called
-#endif
+    sigset_t waitSignal;
-	//Set Signal Mask for suspend until startTask is called
+    sigemptyset(&waitSignal);
-	sigset_t waitSignal;
+    sigaddset(&waitSignal, SIGUSR1);
-	sigemptyset(&waitSignal);
+    status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
-	sigaddset(&waitSignal, SIGUSR1);
+    if(status != 0){
-	status = pthread_sigmask(SIG_BLOCK, &waitSignal, NULL);
+        utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_sigmask");
-	if(status != 0){
+    }
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "Posix Thread sigmask failed failed with: " <<
-				strerror(status) << " errno: " << strerror(errno) << std::endl;
-#endif
-	}
 
-
+    status = pthread_create(&thread,&attributes,fnc_,arg_);
-	status = pthread_create(&thread,&attributes,fnc_,arg_);
+    if(status != 0){
-	if(status != 0){
+        utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_create");
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PosixThread::createTask: Failed with: " <<
+        sif::error << "For FSFW_USE_REALTIME_FOR_LINUX == 1 make sure to call " <<
-				strerror(status) << std::endl;
+                "\"all sudo setcap 'cap_sys_nice=eip'\" on the application or set "
-		sif::error << "For FSFW_USE_REALTIME_FOR_LINUX == 1 make sure to call " <<
+                "/etc/security/limit.conf" << std::endl;
-		        "\"all sudo setcap 'cap_sys_nice=eip'\" on the application or set "
-		        "/etc/security/limit.conf" << std::endl;
 #else
-		sif::printError("PosixThread::createTask: Create failed with: %s\n", strerror(status));
+        sif::printError("For FSFW_USE_REALTIME_FOR_LINUX == 1 make sure to call "
-		sif::printError("For FSFW_USE_REALTIME_FOR_LINUX == 1 make sure to call "
+                "\"all sudo setcap 'cap_sys_nice=eip'\" on the application or set "
-		        "\"all sudo setcap 'cap_sys_nice=eip'\" on the application or set "
                 "/etc/security/limit.conf\n");
 #endif
-	}
+    }
 
-	status = pthread_setname_np(thread,name);
+    status = pthread_setname_np(thread,name);
-	if(status != 0){
+    if(status != 0){
+        utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_setname_np");
+        if(status == ERANGE) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
-		sif::error << "PosixThread::createTask: setname failed with: " <<
+            sif::warning << "PosixThread::createTask: Task name length longer"
-				strerror(status) << std::endl;
+                    " than 16 chars. Truncating.." << std::endl;
+#else
+            sif::printWarning("PosixThread::createTask: Task name length longer"
+                    " than 16 chars. Truncating..\n");
 #endif
-		if(status == ERANGE) {
+            name[15] = '\0';
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+            status = pthread_setname_np(thread,name);
-			sif::error << "PosixThread::createTask: Task name length longer"
+            if(status != 0){
-					" than 16 chars. Truncating.." << std::endl;
+                utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_setname_np");
-#endif
+            }
-			name[15] = '\0';
+        }
-			status = pthread_setname_np(thread,name);
+    }
-			if(status != 0){
-#if FSFW_CPP_OSTREAM_ENABLED == 1
-				sif::error << "PosixThread::createTask: Setting name"
-						" did not work.." << std::endl;
-#endif
-			}
-		}
-	}
 
-	status = pthread_attr_destroy(&attributes);
+    status = pthread_attr_destroy(&attributes);
-	if(status!=0){
+    if (status != 0) {
-#if FSFW_CPP_OSTREAM_ENABLED == 1
+        utility::printUnixErrorGeneric(CLASS_NAME, "createTask", "pthread_attr_destroy");
-		sif::error << "Posix Thread attribute destroy failed with: " <<
+    }
-				strerror(status) << std::endl;
-#endif
-	}
 }

osal/linux/PosixThread.h

@@ -9,69 +9,71 @@
 
 class PosixThread {
 public:
-	static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
+    static constexpr uint8_t PTHREAD_MAX_NAMELEN = 16;
-	PosixThread(const char* name_, int priority_, size_t stackSize_);
+    PosixThread(const char* name_, int priority_, size_t stackSize_);
-	virtual ~PosixThread();
+    virtual ~PosixThread();
-	/**
+    /**
-	 * Set the Thread to sleep state
+     * Set the Thread to sleep state
-	 * @param ns Nanosecond sleep time
+     * @param ns Nanosecond sleep time
-	 * @return Returns Failed if sleep fails
+     * @return Returns Failed if sleep fails
-	 */
+     */
-	static ReturnValue_t sleep(uint64_t ns);
+    static ReturnValue_t sleep(uint64_t ns);
-	/**
+    /**
-	 * @brief Function to suspend the task until SIGUSR1 was received
+     * @brief Function to suspend the task until SIGUSR1 was received
-	 *
+     *
-	 *  @details Will be called in the beginning to suspend execution until startTask() is called explicitly.
+     *  @details Will be called in the beginning to suspend execution until startTask() is called explicitly.
-	 */
+     */
-	void suspend();
+    void suspend();
 
-	/**
+    /**
-	 * @brief Function to allow a other thread to start the thread again from suspend state
+     * @brief Function to allow a other thread to start the thread again from suspend state
-	 *
+     *
-	 * @details Restarts the Thread after suspend call
+     * @details Restarts the Thread after suspend call
-	 */
+     */
-	void resume();
+    void resume();
 
 
-	/**
+    /**
-	 * Delay function similar to FreeRtos delayUntil function
+     * Delay function similar to FreeRtos delayUntil function
-	 *
+     *
-	 * @param prevoiusWakeTime_ms Needs the previous wake time and returns the next wakeup time
+     * @param prevoiusWakeTime_ms Needs the previous wake time and returns the next wakeup time
-	 * @param delayTime_ms Time period to delay
+     * @param delayTime_ms Time period to delay
-	 *
+     *
-	 * @return False If deadline was missed; True if task was delayed
+     * @return False If deadline was missed; True if task was delayed
-	 */
+     */
-	static bool delayUntil(uint64_t* const prevoiusWakeTime_ms, const uint64_t delayTime_ms);
+    static bool delayUntil(uint64_t* const prevoiusWakeTime_ms, const uint64_t delayTime_ms);
 
-	/**
+    /**
-	 * Returns the current time in milliseconds from CLOCK_MONOTONIC
+     * Returns the current time in milliseconds from CLOCK_MONOTONIC
-	 *
+     *
-	 * @return current time in milliseconds from CLOCK_MONOTONIC
+     * @return current time in milliseconds from CLOCK_MONOTONIC
-	 */
+     */
-	static uint64_t getCurrentMonotonicTimeMs();
+    static uint64_t getCurrentMonotonicTimeMs();
 
 protected:
-	pthread_t thread;
+    pthread_t thread;
 
-	/**
+    /**
-	 * @brief 	Function that has to be called by derived class because the
+     * @brief 	Function that has to be called by derived class because the
-	 *  		derived class pointer has to be valid as argument.
+     *  		derived class pointer has to be valid as argument.
-	 * @details
+     * @details
-	 * This function creates a pthread with the given parameters. As the
+     * This function creates a pthread with the given parameters. As the
-	 * function requires a pointer to the derived object it has to be called
+     * function requires a pointer to the derived object it has to be called
-	 * after the this pointer of the derived object is valid.
+     * after the this pointer of the derived object is valid.
-	 * Sets the taskEntryPoint as function to be called by new a thread.
+     * Sets the taskEntryPoint as function to be called by new a thread.
-	 * @param fnc_ Function which will be executed by the thread.
+     * @param fnc_ Function which will be executed by the thread.
-	 * @param arg_
+     * @param arg_
-	 * argument of the taskEntryPoint function, needs to be this pointer
+     * argument of the taskEntryPoint function, needs to be this pointer
-	 * of derived class
+     * of derived class
-	 */
+     */
-	void createTask(void* (*fnc_)(void*),void* arg_);
+    void createTask(void* (*fnc_)(void*),void* arg_);
 
 private:
-	char name[PTHREAD_MAX_NAMELEN];
+    char name[PTHREAD_MAX_NAMELEN];
-	int priority;
+    int priority;
-	size_t stackSize = 0;
+    size_t stackSize = 0;
+
+    static constexpr const char* CLASS_NAME = "PosixThread";
 };
 
 #endif /* FRAMEWORK_OSAL_LINUX_POSIXTHREAD_H_ */

osal/linux/unixUtility.cpp

@@ -0,0 +1,32 @@
+#include "FSFWConfig.h"
+#include "unixUtility.h"
+#include "../../serviceinterface/ServiceInterface.h"
+
+#include <cstring>
+#include <errno.h>
+
+void utility::printUnixErrorGeneric(const char* const className,
+        const char* const function, const char* const failString,
+        sif::OutputTypes outputType) {
+    if(className == nullptr or failString == nullptr or function == nullptr) {
+        return;
+    }
+#if FSFW_VERBOSE_LEVEL >= 1
+    if(outputType == sif::OutputTypes::OUT_ERROR) {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::error << className << "::" << function << ":"  << failString << " error: "
+            << strerror(errno)  << std::endl;
+#else
+    sif::printError("%s::%s: %s error: %s\n", className, function, failString, strerror(errno));
+#endif
+    }
+    else {
+#if FSFW_CPP_OSTREAM_ENABLED == 1
+    sif::warning << className << "::" << function << ":"  << failString << " error: "
+            << strerror(errno)  << std::endl;
+#else
+    sif::printWarning("%s::%s: %s error: %s\n", className, function, failString, strerror(errno));
+#endif
+    }
+#endif
+}

osal/linux/unixUtility.h

@@ -0,0 +1,13 @@
+#ifndef FSFW_OSAL_LINUX_UNIXUTILITY_H_
+#define FSFW_OSAL_LINUX_UNIXUTILITY_H_
+
+#include "../../serviceinterface/serviceInterfaceDefintions.h"
+
+namespace utility {
+
+void printUnixErrorGeneric(const char* const className, const char* const function,
+        const char* const failString, sif::OutputTypes outputType = sif::OutputTypes::OUT_ERROR);
+
+}
+
+#endif /* FSFW_OSAL_LINUX_UNIXUTILITY_H_ */

osal/rtems/FixedTimeslotTask.cpp

@@ -3,7 +3,7 @@
 
 #include "../../tasks/FixedSequenceSlot.h"
 #include "../../objectmanager/SystemObjectIF.h"
-#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManager.h"
 #include "../../returnvalues/HasReturnvaluesIF.h"
 #include "../../serviceinterface/ServiceInterface.h"
 
@@ -81,7 +81,7 @@ ReturnValue_t FixedTimeslotTask::startTask() {
 
 ReturnValue_t FixedTimeslotTask::addSlot(object_id_t componentId,
         uint32_t slotTimeMs, int8_t executionStep) {
-    ExecutableObjectIF* object = objectManager->get<ExecutableObjectIF>(componentId);
+    ExecutableObjectIF* object = ObjectManager::instance()->get<ExecutableObjectIF>(componentId);
     if (object != nullptr) {
         pst.addSlot(componentId, slotTimeMs, executionStep, object, this);
         return HasReturnvaluesIF::RETURN_OK;

osal/rtems/MessageQueue.cpp

@@ -1,8 +1,11 @@
-#include "../../serviceinterface/ServiceInterfaceStream.h"
-#include "../../objectmanager/ObjectManagerIF.h"
 #include "MessageQueue.h"
 #include "RtemsBasic.h"
+
+#include "../../serviceinterface/ServiceInterface.h"
+#include "../../objectmanager/ObjectManager.h"
+
 #include <cstring>
+
 MessageQueue::MessageQueue(size_t message_depth, size_t max_message_size) :
 		id(0), lastPartner(0), defaultDestination(NO_QUEUE), internalErrorReporter(nullptr) {
 	rtems_name name = ('Q' << 24) + (queueCounter++ << 8);
@@ -94,7 +97,7 @@ ReturnValue_t MessageQueue::sendMessageFrom(MessageQueueId_t sendTo,
 	//TODO: Check if we're in ISR.
 	if (result != RTEMS_SUCCESSFUL && !ignoreFault) {
 		if (internalErrorReporter == nullptr) {
-			internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+			internalErrorReporter = ObjectManager::instance()->get<InternalErrorReporterIF>(
 					objects::INTERNAL_ERROR_REPORTER);
 		}
 		if (internalErrorReporter != nullptr) {

osal/rtems/PeriodicTask.cpp

@@ -1,6 +1,7 @@
 #include "PeriodicTask.h"
 
 #include "../../serviceinterface/ServiceInterface.h"
+#include "../../objectmanager/ObjectManager.h"
 #include "../../tasks/ExecutableObjectIF.h"
 
 PeriodicTask::PeriodicTask(const char *name, rtems_task_priority setPriority,
@@ -68,7 +69,7 @@ void PeriodicTask::taskFunctionality() {
 }
 
 ReturnValue_t PeriodicTask::addComponent(object_id_t object) {
-    ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(object);
+    ExecutableObjectIF* newObject = ObjectManager::instance()->get<ExecutableObjectIF>(object);
     if (newObject == nullptr) {
         return HasReturnvaluesIF::RETURN_FAILED;
     }

parameters/ParameterHelper.cpp

@@ -1,6 +1,7 @@
 #include "ParameterHelper.h"
 #include "ParameterMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
+
+#include "../objectmanager/ObjectManager.h"
 
 ParameterHelper::ParameterHelper(ReceivesParameterMessagesIF* owner):
         owner(owner) {}
@@ -124,7 +125,7 @@ ReturnValue_t ParameterHelper::sendParameter(MessageQueueId_t to, uint32_t id,
 ReturnValue_t ParameterHelper::initialize() {
     ownerQueueId = owner->getCommandQueue();
 
-    storage = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+    storage = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
     if (storage == nullptr) {
         return ObjectManagerIF::CHILD_INIT_FAILED;
     }

parameters/ParameterMessage.cpp

@@ -1,5 +1,6 @@
-#include "../parameters/ParameterMessage.h"
+#include "ParameterMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
+
+#include "../objectmanager/ObjectManager.h"
 
 ParameterId_t ParameterMessage::getParameterId(const CommandMessage* message) {
 	return message->getParameter();
@@ -51,7 +52,7 @@ void ParameterMessage::clear(CommandMessage* message) {
 	switch (message->getCommand()) {
 	case CMD_PARAMETER_LOAD:
 	case REPLY_PARAMETER_DUMP: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+		StorageManagerIF *ipcStore = ObjectManager::instance()->get<StorageManagerIF>(
 				objects::IPC_STORE);
 		if (ipcStore != NULL) {
 			ipcStore->deleteData(getStoreId(message));

power/Fuse.cpp

@@ -2,7 +2,7 @@
 
 #include "../monitoring/LimitViolationReporter.h"
 #include "../monitoring/MonitoringMessageContent.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../ipc/QueueFactory.h"
 
@@ -44,7 +44,7 @@ ReturnValue_t Fuse::initialize() {
 	if (result != RETURN_OK) {
 		return result;
 	}
-	powerIF = objectManager->get<PowerSwitchIF>(powerSwitchId);
+	powerIF = ObjectManager::instance()->get<PowerSwitchIF>(powerSwitchId);
 	if (powerIF == NULL) {
 		return RETURN_FAILED;
 	}

power/PowerSwitcher.cpp

@@ -1,7 +1,7 @@
 #include "PowerSwitcher.h"
 
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
 		PowerSwitcher::State_t setStartState):
@@ -10,7 +10,7 @@ PowerSwitcher::PowerSwitcher(uint8_t setSwitch1, uint8_t setSwitch2,
 }
 
 ReturnValue_t PowerSwitcher::initialize(object_id_t powerSwitchId) {
-	power = objectManager->get<PowerSwitchIF>(powerSwitchId);
+	power = ObjectManager::instance()->get<PowerSwitchIF>(powerSwitchId);
 	if (power == nullptr) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}

pus/CService200ModeCommanding.cpp

@@ -2,7 +2,8 @@
 #include "servicepackets/Service200Packets.h"
 
 #include "../modes/HasModesIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../objectmanager/ObjectManager.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../serialize/SerialLinkedListAdapter.h"
 #include "../modes/ModeMessage.h"
 
@@ -40,7 +41,7 @@ ReturnValue_t CService200ModeCommanding::getMessageQueueAndObject(
 
 ReturnValue_t CService200ModeCommanding::checkInterfaceAndAcquireMessageQueue(
         MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
-    HasModesIF * destination = objectManager->get<HasModesIF>(*objectId);
+    HasModesIF * destination = ObjectManager::instance()->get<HasModesIF>(*objectId);
     if(destination == nullptr) {
         return CommandingServiceBase::INVALID_OBJECT;
 

pus/CService201HealthCommanding.cpp

@@ -1,9 +1,11 @@
 #include "CService201HealthCommanding.h"
+#include "servicepackets/Service201Packets.h"
 
 #include "../health/HasHealthIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../health/HealthMessage.h"
-#include "servicepackets/Service201Packets.h"
+
 
 CService201HealthCommanding::CService201HealthCommanding(object_id_t objectId,
         uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
@@ -43,7 +45,7 @@ ReturnValue_t CService201HealthCommanding::getMessageQueueAndObject(
 
 ReturnValue_t CService201HealthCommanding::checkInterfaceAndAcquireMessageQueue(
         MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
-    HasHealthIF * destination = objectManager->get<HasHealthIF>(*objectId);
+    HasHealthIF * destination = ObjectManager::instance()->get<HasHealthIF>(*objectId);
     if(destination == nullptr) {
         return CommandingServiceBase::INVALID_OBJECT;
     }

pus/Service1TelecommandVerification.cpp

@@ -2,6 +2,7 @@
 #include "servicepackets/Service1Packets.h"
 
 #include "../ipc/QueueFactory.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../tmtcservices/PusVerificationReport.h"
 #include "../tmtcpacket/pus/TmPacketStored.h"
 #include "../serviceinterface/ServiceInterfaceStream.h"
@@ -99,7 +100,7 @@ ReturnValue_t Service1TelecommandVerification::generateSuccessReport(
 
 ReturnValue_t Service1TelecommandVerification::initialize() {
 	// Get target object for TC verification messages
-	AcceptsTelemetryIF* funnel = objectManager->
+	AcceptsTelemetryIF* funnel = ObjectManager::instance()->
 			get<AcceptsTelemetryIF>(targetDestination);
 	if(funnel == nullptr){
 #if FSFW_CPP_OSTREAM_ENABLED == 1

pus/Service20ParameterManagement.cpp

@@ -1,11 +1,11 @@
 #include "Service20ParameterManagement.h"
 #include "servicepackets/Service20Packets.h"
 
-#include <fsfw/serviceinterface/ServiceInterface.h>
+#include "../serviceinterface/ServiceInterface.h"
-#include <fsfw/parameters/HasParametersIF.h>
+#include "../parameters/HasParametersIF.h"
-#include <fsfw/parameters/ParameterMessage.h>
+#include "../parameters/ParameterMessage.h"
-#include <fsfw/parameters/ReceivesParameterMessagesIF.h>
+#include "../objectmanager/ObjectManager.h"
-#include <tmtc/pusIds.h>
+#include "../parameters/ReceivesParameterMessagesIF.h"
 
 
 Service20ParameterManagement::Service20ParameterManagement(object_id_t objectId, uint16_t apid,
@@ -65,7 +65,7 @@ ReturnValue_t Service20ParameterManagement::checkInterfaceAndAcquireMessageQueue
         MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
     // check ReceivesParameterMessagesIF property of target
     ReceivesParameterMessagesIF* possibleTarget =
-            objectManager->get<ReceivesParameterMessagesIF>(*objectId);
+            ObjectManager::instance()->get<ReceivesParameterMessagesIF>(*objectId);
     if(possibleTarget == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "Service20ParameterManagement::checkInterfaceAndAcquire"

pus/Service20ParameterManagement.h

@@ -1,7 +1,7 @@
 #ifndef FSFW_PUS_SERVICE20PARAMETERMANAGEMENT_H_
 #define FSFW_PUS_SERVICE20PARAMETERMANAGEMENT_H_
 
-#include <fsfw/tmtcservices/CommandingServiceBase.h>
+#include "../tmtcservices/CommandingServiceBase.h"
 
 /**
  * @brief   PUS Service 20 Parameter Service implementation

pus/Service2DeviceAccess.cpp

@@ -1,6 +1,7 @@
 #include "Service2DeviceAccess.h"
 #include "servicepackets/Service2Packets.h"
 
+#include "../objectmanager/ObjectManager.h"
 #include "../devicehandlers/DeviceHandlerIF.h"
 #include "../storagemanager/StorageManagerIF.h"
 #include "../devicehandlers/DeviceHandlerMessage.h"
@@ -47,7 +48,7 @@ ReturnValue_t Service2DeviceAccess::getMessageQueueAndObject(
 ReturnValue_t Service2DeviceAccess::checkInterfaceAndAcquireMessageQueue(
 		MessageQueueId_t * messageQueueToSet, object_id_t *objectId) {
 	DeviceHandlerIF* possibleTarget =
-			objectManager->get<DeviceHandlerIF>(*objectId);
+	        ObjectManager::instance()->get<DeviceHandlerIF>(*objectId);
 	if(possibleTarget == nullptr) {
 		return CommandingServiceBase::INVALID_OBJECT;
 	}

pus/Service3Housekeeping.cpp

@@ -1,7 +1,8 @@
 #include "Service3Housekeeping.h"
 #include "servicepackets/Service3Packets.h"
-#include "../datapoollocal/HasLocalDataPoolIF.h"
 
+#include "../objectmanager/ObjectManager.h"
+#include "../datapoollocal/HasLocalDataPoolIF.h"
 
 Service3Housekeeping::Service3Housekeeping(object_id_t objectId, uint16_t apid,
         uint8_t serviceId):
@@ -56,7 +57,7 @@ ReturnValue_t Service3Housekeeping::checkInterfaceAndAcquireMessageQueue(
         MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
     // check HasLocalDataPoolIF property of target
     HasLocalDataPoolIF* possibleTarget =
-            objectManager->get<HasLocalDataPoolIF>(*objectId);
+            ObjectManager::instance()->get<HasLocalDataPoolIF>(*objectId);
     if(possibleTarget == nullptr){
         return CommandingServiceBase::INVALID_OBJECT;
     }

pus/Service5EventReporting.cpp

@@ -1,7 +1,8 @@
 #include "Service5EventReporting.h"
 #include "servicepackets/Service5Packets.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../events/EventManagerIF.h"
 #include "../ipc/QueueFactory.h"
 #include "../tmtcpacket/pus/TmPacketStored.h"
@@ -89,7 +90,7 @@ ReturnValue_t Service5EventReporting::handleRequest(uint8_t 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>(
+	EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(
 				objects::EVENT_MANAGER);
 	if (manager == NULL) {
 			return RETURN_FAILED;

pus/Service8FunctionManagement.cpp

@@ -1,11 +1,12 @@
 #include "Service8FunctionManagement.h"
 #include "servicepackets/Service8Packets.h"
 
+#include "../objectmanager/ObjectManager.h"
 #include "../objectmanager/SystemObjectIF.h"
 #include "../action/HasActionsIF.h"
 #include "../devicehandlers/DeviceHandlerIF.h"
 #include "../serialize/SerializeAdapter.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 
 Service8FunctionManagement::Service8FunctionManagement(object_id_t objectId,
 		uint16_t apid, uint8_t serviceId, uint8_t numParallelCommands,
@@ -41,7 +42,7 @@ ReturnValue_t Service8FunctionManagement::getMessageQueueAndObject(
 ReturnValue_t Service8FunctionManagement::checkInterfaceAndAcquireMessageQueue(
 		MessageQueueId_t* messageQueueToSet, object_id_t* objectId) {
 	// check HasActionIF property of target
-	HasActionsIF* possibleTarget = objectManager->get<HasActionsIF>(*objectId);
+	HasActionsIF* possibleTarget = ObjectManager::instance()->get<HasActionsIF>(*objectId);
 	if(possibleTarget == nullptr){
 		return CommandingServiceBase::INVALID_OBJECT;
 	}

returnvalues/FwClassIds.h

@@ -72,6 +72,9 @@ enum: uint8_t {
     PUS_SERVICE_3, //PUS3
     PUS_SERVICE_9, //PUS9
     FILE_SYSTEM, //FILS
+    HAL_SPI, //HSPI
+    HAL_UART, //HURT
+    HAL_I2C, //HI2C
     FW_CLASS_ID_COUNT // [EXPORT] : [END]
 
 };

serviceinterface/ServiceInterfacePrinter.h

@@ -7,6 +7,8 @@
 
 //! https://stackoverflow.com/questions/111928/is-there-a-printf-converter-to-print-in-binary-format
 //! Can be used to print out binary numbers in human-readable format.
+//! Example usage:
+//! sif::printInfo("Status register: " BYTE_TO_BINARY_PATTERN "\n",BYTE_TO_BINARY(0x1f));
 #define BYTE_TO_BINARY_PATTERN "%c%c%c%c%c%c%c%c"
 #define BYTE_TO_BINARY(byte)  \
   (byte & 0x80 ? '1' : '0'), \

storagemanager/LocalPool.cpp

@@ -1,5 +1,8 @@
 #include "LocalPool.h"
-#include <FSFWConfig.h>
+#include "FSFWConfig.h"
+
+#include "../objectmanager/ObjectManager.h"
+
 #include <cstring>
 
 LocalPool::LocalPool(object_id_t setObjectId, const LocalPoolConfig& poolConfig,
@@ -185,7 +188,7 @@ ReturnValue_t LocalPool::initialize() {
     if (result != RETURN_OK) {
         return result;
     }
-    internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+    internalErrorReporter = ObjectManager::instance()->get<InternalErrorReporterIF>(
             objects::INTERNAL_ERROR_REPORTER);
     if (internalErrorReporter == nullptr){
         return ObjectManagerIF::INTERNAL_ERR_REPORTER_UNINIT;

subsystem/Subsystem.cpp

@@ -1,6 +1,7 @@
 #include "Subsystem.h"
+
 #include "../health/HealthMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../serialize/SerialArrayListAdapter.h"
 #include "../serialize/SerialFixedArrayListAdapter.h"
 #include "../serialize/SerializeElement.h"
@@ -477,13 +478,13 @@ ReturnValue_t Subsystem::initialize() {
 		return result;
 	}
 
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	IPCStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
 	if (IPCStore == NULL) {
 		return RETURN_FAILED;
 	}
 
 #if FSFW_USE_MODESTORE == 1
-	modeStore = objectManager->get<ModeStoreIF>(objects::MODE_STORE);
+	modeStore = ObjectManager::instance()->get<ModeStoreIF>(objects::MODE_STORE);
 
 	if (modeStore == nullptr) {
 		return RETURN_FAILED;

subsystem/SubsystemBase.cpp

@@ -1,6 +1,7 @@
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "SubsystemBase.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+
-#include "../subsystem/SubsystemBase.h"
+#include "../serviceinterface/ServiceInterface.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../ipc/QueueFactory.h"
 
 SubsystemBase::SubsystemBase(object_id_t setObjectId, object_id_t parent,
@@ -19,10 +20,10 @@ SubsystemBase::~SubsystemBase() {
 ReturnValue_t SubsystemBase::registerChild(object_id_t objectId) {
 	ChildInfo info;
 
-	HasModesIF *child = objectManager->get<HasModesIF>(objectId);
+	HasModesIF *child = ObjectManager::instance()->get<HasModesIF>(objectId);
 	// This is a rather ugly hack to have the changedHealth info for all
 	// children available.
-	HasHealthIF* healthChild = objectManager->get<HasHealthIF>(objectId);
+	HasHealthIF* healthChild = ObjectManager::instance()->get<HasHealthIF>(objectId);
 	if (child == nullptr) {
 		if (healthChild == nullptr) {
 			return CHILD_DOESNT_HAVE_MODES;
@@ -174,7 +175,7 @@ ReturnValue_t SubsystemBase::initialize() {
 	}
 
 	if (parentId != objects::NO_OBJECT) {
-		SubsystemBase *parent = objectManager->get<SubsystemBase>(parentId);
+		SubsystemBase *parent = ObjectManager::instance()->get<SubsystemBase>(parentId);
 		if (parent == nullptr) {
 			return RETURN_FAILED;
 		}

subsystem/modes/ModeSequenceMessage.cpp

@@ -1,6 +1,6 @@
 #include "ModeSequenceMessage.h"
 
-#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManager.h"
 #include "../../storagemanager/StorageManagerIF.h"
 
 void ModeSequenceMessage::setModeSequenceMessage(CommandMessage* message,
@@ -50,7 +50,7 @@ void ModeSequenceMessage::clear(CommandMessage *message) {
 	case TABLE_LIST:
 	case TABLE:
 	case SEQUENCE: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+		StorageManagerIF *ipcStore = ObjectManager::instance()->get<StorageManagerIF>(
 		        objects::IPC_STORE);
 		if (ipcStore != nullptr){
 			ipcStore->deleteData(ModeSequenceMessage::getStoreAddress(message));

tcdistribution/CCSDSDistributor.cpp

@@ -1,5 +1,6 @@
 #include "CCSDSDistributor.h"
 
+#include "../objectmanager/ObjectManager.h"
 #include "../serviceinterface/ServiceInterface.h"
 #include "../tmtcpacket/SpacePacketBase.h"
 
@@ -86,7 +87,7 @@ uint16_t CCSDSDistributor::getIdentifier() {
 
 ReturnValue_t CCSDSDistributor::initialize() {
 	ReturnValue_t status = this->TcDistributor::initialize();
-	this->tcStore = objectManager->get<StorageManagerIF>( objects::TC_STORE );
+	this->tcStore = ObjectManager::instance()->get<StorageManagerIF>( objects::TC_STORE );
 	if (this->tcStore == nullptr) {
 #if FSFW_VERBOSE_LEVEL >= 1
 #if FSFW_CPP_OSTREAM_ENABLED == 1

tcdistribution/PUSDistributor.cpp

@@ -1,6 +1,7 @@
 #include "CCSDSDistributorIF.h"
 #include "PUSDistributor.h"
 
+#include "../objectmanager/ObjectManager.h"
 #include "../serviceinterface/ServiceInterface.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcservices/PusVerificationReport.h"
@@ -125,7 +126,7 @@ ReturnValue_t PUSDistributor::initialize() {
     }
 
     CCSDSDistributorIF* ccsdsDistributor =
-            objectManager->get<CCSDSDistributorIF>(packetSource);
+            ObjectManager::instance()->get<CCSDSDistributorIF>(packetSource);
     if (ccsdsDistributor == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
         sif::error << "PUSDistributor::initialize: Packet source invalid" << std::endl;

thermal/Heater.cpp

@@ -1,5 +1,6 @@
 #include "Heater.h"
 
+#include "../objectmanager/ObjectManager.h"
 #include "../devicehandlers/DeviceHandlerFailureIsolation.h"
 #include "../power/Fuse.h"
 #include "../ipc/QueueFactory.h"
@@ -239,7 +240,7 @@ ReturnValue_t Heater::initialize() {
         return result;
     }
 
-    EventManagerIF* manager = objectManager->get<EventManagerIF>(
+    EventManagerIF* manager = ObjectManager::instance()->get<EventManagerIF>(
             objects::EVENT_MANAGER);
     if (manager == NULL) {
         return HasReturnvaluesIF::RETURN_FAILED;
@@ -249,7 +250,7 @@ ReturnValue_t Heater::initialize() {
         return result;
     }
 
-    ConfirmsFailuresIF* pcdu = objectManager->get<ConfirmsFailuresIF>(
+    ConfirmsFailuresIF* pcdu = ObjectManager::instance()->get<ConfirmsFailuresIF>(
             DeviceHandlerFailureIsolation::powerConfirmationId);
     if (pcdu == NULL) {
         return HasReturnvaluesIF::RETURN_FAILED;

tmstorage/TmStoreMessage.cpp

@@ -1,5 +1,5 @@
 #include "TmStoreMessage.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 
 TmStoreMessage::~TmStoreMessage() {
 	
@@ -64,7 +64,7 @@ void TmStoreMessage::clear(CommandMessage* cmd) {
 	case INDEX_REPORT:
 	case DELETE_STORE_CONTENT_TIME:
 	case DOWNLINK_STORE_CONTENT_TIME: {
-		StorageManagerIF *ipcStore = objectManager->get<StorageManagerIF>(
+		StorageManagerIF *ipcStore = ObjectManager::instance()->get<StorageManagerIF>(
 				objects::IPC_STORE);
 		if (ipcStore != NULL) {
 			ipcStore->deleteData(getStoreId(cmd));

tmtcpacket/pus/TcPacketStored.cpp

@@ -1,6 +1,7 @@
 #include "TcPacketStored.h"
-#include "../../objectmanager/ObjectManagerIF.h"
+
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../objectmanager/ObjectManager.h"
+#include "../../serviceinterface/ServiceInterface.h"
 
 #include <cstring>
 
@@ -63,7 +64,7 @@ ReturnValue_t TcPacketStored::deletePacket() {
 
 bool TcPacketStored::checkAndSetStore() {
 	if (this->store == nullptr) {
-		this->store = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+		this->store = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
 		if (this->store == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 			sif::error << "TcPacketStored::TcPacketStored: TC Store not found!"

tmtcpacket/pus/TmPacketBase.cpp

@@ -2,7 +2,7 @@
 
 #include "../../globalfunctions/CRC.h"
 #include "../../globalfunctions/arrayprinter.h"
-#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManager.h"
 #include "../../serviceinterface/ServiceInterface.h"
 #include "../../timemanager/CCSDSTime.h"
 
@@ -53,7 +53,7 @@ void TmPacketBase::print() {
 
 bool TmPacketBase::checkAndSetStamper() {
     if (timeStamper == NULL) {
-        timeStamper = objectManager->get<TimeStamperIF>(timeStamperId);
+        timeStamper = ObjectManager::instance()->get<TimeStamperIF>(timeStamperId);
         if (timeStamper == NULL) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::warning << "TmPacketBase::checkAndSetStamper: Stamper not found!" << std::endl;

tmtcpacket/pus/TmPacketStoredBase.cpp

@@ -1,7 +1,7 @@
 #include "TmPacketStoredBase.h"
 
-#include "../../objectmanager/ObjectManagerIF.h"
+#include "../../objectmanager/ObjectManager.h"
-#include "../../serviceinterface/ServiceInterfaceStream.h"
+#include "../../serviceinterface/ServiceInterface.h"
 #include "../../tmtcservices/TmTcMessage.h"
 
 #include <cstring>
@@ -48,7 +48,7 @@ void TmPacketStoredBase::setStoreAddress(store_address_t setAddress) {
 
 bool TmPacketStoredBase::checkAndSetStore() {
     if (store == nullptr) {
-        store = objectManager->get<StorageManagerIF>(objects::TM_STORE);
+        store = ObjectManager::instance()->get<StorageManagerIF>(objects::TM_STORE);
         if (store == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
             sif::error << "TmPacketStored::TmPacketStored: TM Store not found!"
@@ -83,7 +83,7 @@ ReturnValue_t TmPacketStoredBase::sendPacket(MessageQueueId_t destination,
 
 void TmPacketStoredBase::checkAndReportLostTm() {
     if (internalErrorReporter == nullptr) {
-        internalErrorReporter = objectManager->get<InternalErrorReporterIF>(
+        internalErrorReporter = ObjectManager::instance()->get<InternalErrorReporterIF>(
                 objects::INTERNAL_ERROR_REPORTER);
     }
     if (internalErrorReporter != nullptr) {

tmtcservices/CommandingServiceBase.cpp

@@ -4,7 +4,7 @@
 #include <FSFWConfig.h>
 
 #include "../tcdistribution/PUSDistributorIF.h"
-#include "../objectmanager/ObjectManagerIF.h"
+#include "../objectmanager/ObjectManager.h"
 #include "../ipc/QueueFactory.h"
 #include "../tmtcpacket/pus/TcPacketStored.h"
 #include "../tmtcpacket/pus/TmPacketStored.h"
@@ -68,12 +68,12 @@ ReturnValue_t CommandingServiceBase::initialize() {
 	    packetDestination = defaultPacketDestination;
 	}
 	AcceptsTelemetryIF* packetForwarding =
-			objectManager->get<AcceptsTelemetryIF>(packetDestination);
+	        ObjectManager::instance()->get<AcceptsTelemetryIF>(packetDestination);
 
 	if(packetSource == objects::NO_OBJECT) {
 	    packetSource = defaultPacketSource;
 	}
-	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
+	PUSDistributorIF* distributor = ObjectManager::instance()->get<PUSDistributorIF>(
 			packetSource);
 
 	if (packetForwarding == nullptr or distributor == nullptr) {
@@ -88,8 +88,8 @@ ReturnValue_t CommandingServiceBase::initialize() {
 	requestQueue->setDefaultDestination(
 			packetForwarding->getReportReceptionQueue());
 
-	IPCStore = objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+	IPCStore = ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
-	TCStore = objectManager->get<StorageManagerIF>(objects::TC_STORE);
+	TCStore = ObjectManager::instance()->get<StorageManagerIF>(objects::TC_STORE);
 
 	if (IPCStore == nullptr or TCStore == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1

tmtcservices/PusServiceBase.cpp

@@ -3,7 +3,8 @@
 #include "PusVerificationReport.h"
 #include "TmTcMessage.h"
 
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../objectmanager/ObjectManager.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../tcdistribution/PUSDistributorIF.h"
 #include "../ipc/QueueFactory.h"
 
@@ -105,9 +106,9 @@ ReturnValue_t PusServiceBase::initialize() {
 	if (result != RETURN_OK) {
 		return result;
 	}
-	AcceptsTelemetryIF* destService = objectManager->get<AcceptsTelemetryIF>(
+	AcceptsTelemetryIF* destService = ObjectManager::instance()->get<AcceptsTelemetryIF>(
 			packetDestination);
-	PUSDistributorIF* distributor = objectManager->get<PUSDistributorIF>(
+	PUSDistributorIF* distributor = ObjectManager::instance()->get<PUSDistributorIF>(
 			packetSource);
 	if (destService == nullptr or distributor == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1

tmtcservices/TmTcBridge.cpp

@@ -1,5 +1,6 @@
 #include "TmTcBridge.h"
 
+#include "../objectmanager/ObjectManager.h"
 #include "../ipc/QueueFactory.h"
 #include "../serviceinterface/ServiceInterface.h"
 #include "../globalfunctions/arrayprinter.h"
@@ -53,7 +54,7 @@ ReturnValue_t TmTcBridge::setMaxNumberOfPacketsStored(
 }
 
 ReturnValue_t TmTcBridge::initialize() {
-	tcStore = objectManager->get<StorageManagerIF>(tcStoreId);
+	tcStore = ObjectManager::instance()->get<StorageManagerIF>(tcStoreId);
 	if (tcStore == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TC store invalid. Make sure"
@@ -61,7 +62,7 @@ ReturnValue_t TmTcBridge::initialize() {
 #endif
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
-	tmStore = objectManager->get<StorageManagerIF>(tmStoreId);
+	tmStore = ObjectManager::instance()->get<StorageManagerIF>(tmStoreId);
 	if (tmStore == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TM store invalid. Make sure"
@@ -70,7 +71,7 @@ ReturnValue_t TmTcBridge::initialize() {
 		return ObjectManagerIF::CHILD_INIT_FAILED;
 	}
 	AcceptsTelecommandsIF* tcDistributor =
-			objectManager->get<AcceptsTelecommandsIF>(tcDestination);
+	        ObjectManager::instance()->get<AcceptsTelecommandsIF>(tcDestination);
 	if (tcDistributor == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "TmTcBridge::initialize: TC Distributor invalid"

tmtcservices/VerificationReporter.cpp

@@ -2,8 +2,9 @@
 #include "AcceptsVerifyMessageIF.h"
 #include "PusVerificationReport.h"
 
+#include "../objectmanager/ObjectManager.h"
 #include "../ipc/MessageQueueIF.h"
-#include "../serviceinterface/ServiceInterfaceStream.h"
+#include "../serviceinterface/ServiceInterface.h"
 #include "../objectmanager/frameworkObjects.h"
 
 object_id_t VerificationReporter::messageReceiver =
@@ -104,7 +105,7 @@ void VerificationReporter::initialize() {
 #endif
 		return;
 	}
-	AcceptsVerifyMessageIF* temp = objectManager->get<AcceptsVerifyMessageIF>(
+	AcceptsVerifyMessageIF* temp = ObjectManager::instance()->get<AcceptsVerifyMessageIF>(
 			messageReceiver);
 	if (temp == nullptr) {
 #if FSFW_CPP_OSTREAM_ENABLED == 1

unittest/tests/datapoollocal/DataSetTest.cpp

@@ -3,6 +3,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/catch_approx.hpp>
 
+#include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/SharedLocalDataSet.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
@@ -12,7 +13,7 @@
 #include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE("DataSetTest" , "[DataSetTest]") {
-    LocalPoolOwnerBase* poolOwner = objectManager->
+    LocalPoolOwnerBase* poolOwner = ObjectManager::instance()->
             get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
     REQUIRE(poolOwner != nullptr);
     REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);

unittest/tests/datapoollocal/LocalPoolManagerTest.cpp

@@ -3,6 +3,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/catch_approx.hpp>
 
+#include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/datapool/PoolReadGuard.h>
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/StaticLocalDataSet.h>
@@ -14,7 +15,7 @@
 
 
 TEST_CASE("LocalPoolManagerTest" , "[LocManTest]") {
-    LocalPoolOwnerBase* poolOwner = objectManager->
+    LocalPoolOwnerBase* poolOwner = ObjectManager::instance()->
             get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
     REQUIRE(poolOwner != nullptr);
     REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);

unittest/tests/datapoollocal/LocalPoolOwnerBase.h

@@ -1,7 +1,7 @@
 #ifndef FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
 #define FSFW_UNITTEST_TESTS_DATAPOOLLOCAL_LOCALPOOLOWNERBASE_H_
 
-#include <testcfg/objects/systemObjectList.h>
+#include "objects/systemObjectList.h"
 
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <fsfw/datapoollocal/LocalDataSet.h>

unittest/tests/datapoollocal/LocalPoolVariableTest.cpp

@@ -1,12 +1,13 @@
 #include "LocalPoolOwnerBase.h"
 
 #include <catch2/catch_test_macros.hpp>
+#include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <unittest/core/CatchDefinitions.h>
 
 
 TEST_CASE("LocalPoolVariable" , "[LocPoolVarTest]") {
-    LocalPoolOwnerBase* poolOwner = objectManager->
+    LocalPoolOwnerBase* poolOwner = ObjectManager::instance()->
             get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
     REQUIRE(poolOwner != nullptr);
     REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);

unittest/tests/datapoollocal/LocalPoolVectorTest.cpp

@@ -1,11 +1,12 @@
 #include "LocalPoolOwnerBase.h"
 
 #include <catch2/catch_test_macros.hpp>
+#include <fsfw/objectmanager/ObjectManager.h>
 #include <fsfw/datapoollocal/HasLocalDataPoolIF.h>
 #include <unittest/core/CatchDefinitions.h>
 
 TEST_CASE("LocalPoolVector" , "[LocPoolVecTest]") {
-    LocalPoolOwnerBase* poolOwner = objectManager->
+    LocalPoolOwnerBase* poolOwner = ObjectManager::instance()->
             get<LocalPoolOwnerBase>(objects::TEST_LOCAL_POOL_OWNER_BASE);
     REQUIRE(poolOwner != nullptr);
     REQUIRE(poolOwner->initializeHkManager() == retval::CATCH_OK);

unittest/user/unittest/core/CatchDefinitions.cpp

@@ -1,10 +1,10 @@
 #include "CatchDefinitions.h"
 #include <fsfw/serviceinterface/ServiceInterface.h>
-#include <fsfw/objectmanager/ObjectManagerIF.h>
+#include <fsfw/objectmanager/ObjectManager.h>
 
 StorageManagerIF* tglob::getIpcStoreHandle() {
-	if(objectManager != nullptr) {
+	if(ObjectManager::instance() != nullptr) {
-		return objectManager->get<StorageManagerIF>(objects::IPC_STORE);
+		return ObjectManager::instance()->get<StorageManagerIF>(objects::IPC_STORE);
 	} else {
 #if FSFW_CPP_OSTREAM_ENABLED == 1
 		sif::error << "Global object manager uninitialized" << std::endl;

unittest/user/unittest/core/CatchFactory.h

@@ -8,7 +8,7 @@ namespace Factory {
 	 * @brief 	Creates all SystemObject elements which are persistent
 	 * 			during execution.
 	 */
-	void produce();
+	void produce(void* args);
 	void setStaticFrameworkObjectIds();
 
 }