diff --git a/datapool/DataPool.cpp b/datapool/DataPool.cpp
index 817089bf..1b6cb7a1 100644
--- a/datapool/DataPool.cpp
+++ b/datapool/DataPool.cpp
@@ -61,7 +61,7 @@ ReturnValue_t DataPool::freeDataPoolLock() {
 }
 
 ReturnValue_t DataPool::lockDataPool() {
-	ReturnValue_t status = mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t status = mutex->lockMutex(MutexIF::BLOCKING);
 	if ( status != RETURN_OK ) {
 		sif::error << "DataPool::DataPool: lock of mutex failed with error code: " << status << std::endl;
 	}
diff --git a/events/EventManager.cpp b/events/EventManager.cpp
index fb4499b2..e58f251a 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -147,7 +147,7 @@ void EventManager::printEvent(EventMessage* message) {
 #endif
 
 void EventManager::lockMutex() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 }
 
 void EventManager::unlockMutex() {
diff --git a/health/HealthTable.cpp b/health/HealthTable.cpp
index 846152f6..4d2564a3 100644
--- a/health/HealthTable.cpp
+++ b/health/HealthTable.cpp
@@ -26,7 +26,7 @@ ReturnValue_t HealthTable::registerObject(object_id_t object,
 
 void HealthTable::setHealth(object_id_t object,
 		HasHealthIF::HealthState newState) {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		iter->second = newState;
@@ -36,7 +36,7 @@ void HealthTable::setHealth(object_id_t object,
 
 HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 	HasHealthIF::HealthState state = HasHealthIF::HEALTHY;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		state = iter->second;
@@ -46,7 +46,7 @@ HasHealthIF::HealthState HealthTable::getHealth(object_id_t object) {
 }
 
 uint32_t HealthTable::getPrintSize() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	uint32_t size = healthMap.size() * 5 + 2;
 	mutex->unlockMutex();
 	return size;
@@ -54,7 +54,7 @@ uint32_t HealthTable::getPrintSize() {
 
 bool HealthTable::hasHealth(object_id_t object) {
 	bool exits = false;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	HealthMap::iterator iter = healthMap.find(object);
 	if (iter != healthMap.end()) {
 		exits = true;
@@ -64,7 +64,7 @@ bool HealthTable::hasHealth(object_id_t object) {
 }
 
 void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	size_t size = 0;
 	uint16_t count = healthMap.size();
 	ReturnValue_t result = SerializeAdapter::serialize(&count,
@@ -85,7 +85,7 @@ void HealthTable::printAll(uint8_t* pointer, size_t maxSize) {
 ReturnValue_t HealthTable::iterate(
 		std::pair<object_id_t, HasHealthIF::HealthState> *value, bool reset) {
 	ReturnValue_t result = HasReturnvaluesIF::RETURN_OK;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	if (reset) {
 		mapIterator = healthMap.begin();
 	}
diff --git a/internalError/InternalErrorReporter.cpp b/internalError/InternalErrorReporter.cpp
index b468ca5e..861e1595 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -54,7 +54,7 @@ void InternalErrorReporter::lostTm() {
 
 uint32_t InternalErrorReporter::getAndResetQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = queueHits;
 	queueHits = 0;
 	mutex->unlockMutex();
@@ -63,21 +63,21 @@ uint32_t InternalErrorReporter::getAndResetQueueHits() {
 
 uint32_t InternalErrorReporter::getQueueHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = queueHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementQueueHits() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	queueHits++;
 	mutex->unlockMutex();
 }
 
 uint32_t InternalErrorReporter::getAndResetTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = tmHits;
 	tmHits = 0;
 	mutex->unlockMutex();
@@ -86,14 +86,14 @@ uint32_t InternalErrorReporter::getAndResetTmHits() {
 
 uint32_t InternalErrorReporter::getTmHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = tmHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementTmHits() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	tmHits++;
 	mutex->unlockMutex();
 }
@@ -104,7 +104,7 @@ void InternalErrorReporter::storeFull() {
 
 uint32_t InternalErrorReporter::getAndResetStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = storeHits;
 	storeHits = 0;
 	mutex->unlockMutex();
@@ -113,14 +113,14 @@ uint32_t InternalErrorReporter::getAndResetStoreHits() {
 
 uint32_t InternalErrorReporter::getStoreHits() {
 	uint32_t value;
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	value = storeHits;
 	mutex->unlockMutex();
 	return value;
 }
 
 void InternalErrorReporter::incrementStoreHits() {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	storeHits++;
 	mutex->unlockMutex();
 }
diff --git a/ipc/MutexHelper.h b/ipc/MutexHelper.h
index dffcd54e..3dc36921 100644
--- a/ipc/MutexHelper.h
+++ b/ipc/MutexHelper.h
@@ -6,15 +6,21 @@
 
 class MutexHelper {
 public:
-	MutexHelper(MutexIF* mutex, uint32_t timeoutMs) :
+	MutexHelper(MutexIF* mutex, MutexIF::TimeoutType timeoutType =
+			MutexIF::TimeoutType::BLOCKING, uint32_t timeoutMs = 0) :
 			internalMutex(mutex) {
-		ReturnValue_t status = mutex->lockMutex(timeoutMs);
-		if(status != HasReturnvaluesIF::RETURN_OK){
-			sif::error << "MutexHelper: Lock of Mutex failed " << status << std::endl;
+		ReturnValue_t status = mutex->lockMutex(timeoutType,
+		        timeoutMs);
+		if(status == MutexIF::MUTEX_TIMEOUT) {
+			sif::error << "MutexHelper: Lock of mutex failed with timeout of "
+					<< timeoutMs << " milliseconds!" << std::endl;
+		}
+		else if(status != HasReturnvaluesIF::RETURN_OK){
+			sif::error << "MutexHelper: Lock of Mutex failed with code " <<
+					status << std::endl;
 		}
 	}
 
-
 	~MutexHelper() {
 		internalMutex->unlockMutex();
 	}
diff --git a/ipc/MutexIF.h b/ipc/MutexIF.h
index 851d50a1..5673e4d7 100644
--- a/ipc/MutexIF.h
+++ b/ipc/MutexIF.h
@@ -3,9 +3,33 @@
 
 #include "../returnvalues/HasReturnvaluesIF.h"
 
+/**
+ * @brief Common interface for OS Mutex objects which provide MUTual EXclusion.
+ * @details https://en.wikipedia.org/wiki/Lock_(computer_science)
+ * @ingroup osal
+ * @ingroup interface
+ */
 class MutexIF {
 public:
-	static const uint32_t NO_TIMEOUT; //!< Needs to be defined in implementation.
+    /**
+     * Different types of timeout for the mutex lock.
+     */
+    enum TimeoutType {
+        POLLING, //!< If mutex is not available, return immediately
+        WAITING, //!< Wait a specified time for the mutex to become available
+        BLOCKING //!< Block indefinitely until the mutex becomes available.
+    };
+
+    /**
+     * Lock the mutex. The timeout value will only be used for
+     * TimeoutType::WAITING
+     * @param timeoutType
+     * @param timeoutMs
+     * @return
+     */
+    virtual ReturnValue_t lockMutex(TimeoutType timeoutType =
+            TimeoutType::BLOCKING, uint32_t timeoutMs = 0) = 0;
+    virtual ReturnValue_t unlockMutex() = 0;
 
 	static const uint8_t INTERFACE_ID = CLASS_ID::MUTEX_IF;
 	/**
@@ -57,9 +81,7 @@ public:
 	 */
 	static const ReturnValue_t MUTEX_DESTROYED_WHILE_WAITING = MAKE_RETURN_CODE(12);
 
-	virtual ~MutexIF() {}
-	virtual ReturnValue_t lockMutex(uint32_t timeoutMs) = 0;
-	virtual ReturnValue_t unlockMutex() = 0;
+    virtual ~MutexIF() {}
 };
 
 
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index 9733c405..acfa98d7 100644
--- a/osal/FreeRTOS/Clock.cpp
+++ b/osal/FreeRTOS/Clock.cpp
@@ -155,7 +155,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if (checkOrCreateClockMutex() != HasReturnvaluesIF::RETURN_OK) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -170,7 +170,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if (timeMutex == NULL) {
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index 6da58783..e5896c41 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -1,28 +1,32 @@
-#include "Mutex.h"
+#include <framework/osal/FreeRTOS/Mutex.h>
 
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-const uint32_t MutexIF::NO_TIMEOUT = 0;
-
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
-	//TODO print error
+	if(handle == nullptr) {
+		sif::error << "Mutex::Mutex(FreeRTOS): Creation failure" << std::endl;
+	}
 }
 
 Mutex::~Mutex() {
-	if (handle != 0) {
+	if (handle != nullptr) {
 		vSemaphoreDelete(handle);
 	}
 
 }
 
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	if (handle == 0) {
-		//TODO Does not exist
-		return HasReturnvaluesIF::RETURN_FAILED;
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType,
+        uint32_t timeoutMs) {
+	if (handle == nullptr) {
+		return MutexIF::MUTEX_NOT_FOUND;
 	}
-	TickType_t timeout = portMAX_DELAY;
-	if (timeoutMs != NO_TIMEOUT) {
+	// If the timeout type is BLOCKING, this will be the correct value.
+	uint32_t timeout = portMAX_DELAY;
+	if(timeoutType == TimeoutType::POLLING) {
+		timeout = 0;
+	}
+	else if(timeoutType == TimeoutType::WAITING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
@@ -30,21 +34,18 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		//TODO could not be acquired/timeout
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return MutexIF::MUTEX_TIMEOUT;
 	}
 }
 
 ReturnValue_t Mutex::unlockMutex() {
-	if (handle == 0) {
-		//TODO Does not exist
-		return HasReturnvaluesIF::RETURN_FAILED;
+	if (handle == nullptr) {
+		return MutexIF::MUTEX_NOT_FOUND;
 	}
 	BaseType_t returncode = xSemaphoreGive(handle);
 	if (returncode == pdPASS) {
 		return HasReturnvaluesIF::RETURN_OK;
 	} else {
-		//TODO is not owner
-		return HasReturnvaluesIF::RETURN_FAILED;
+		return MutexIF::CURR_THREAD_DOES_NOT_OWN_MUTEX;
 	}
 }
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index d376b7bc..156d431c 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -1,22 +1,29 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
+#ifndef FRAMEWORK_FREERTOS_MUTEX_H_
+#define FRAMEWORK_FREERTOS_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
 
-#include <FreeRTOS.h>
-#include "semphr.h"
-
-
-
+/**
+ * @brief OS component to implement MUTual EXclusion
+ *
+ * @details
+ * Mutexes are binary semaphores which include a priority inheritance mechanism.
+ * Documentation: https://www.freertos.org/Real-time-embedded-RTOS-mutexes.html
+ * @ingroup osal
+ */
 class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs);
-	ReturnValue_t unlockMutex();
+	ReturnValue_t lockMutex(TimeoutType timeoutType,
+	        uint32_t timeoutMs) override;
+	ReturnValue_t unlockMutex() override;
+
 private:
 	SemaphoreHandle_t handle;
 };
 
-#endif /* OS_RTEMS_MUTEX_H_ */
+#endif /* FRAMEWORK_FREERTOS_MUTEX_H_ */
diff --git a/osal/linux/Clock.cpp b/osal/linux/Clock.cpp
index 48e325ef..5f764a6f 100644
--- a/osal/linux/Clock.cpp
+++ b/osal/linux/Clock.cpp
@@ -179,7 +179,7 @@ ReturnValue_t Clock::setLeapSeconds(const uint16_t leapSeconds_) {
 	if(checkOrCreateClockMutex()!=HasReturnvaluesIF::RETURN_OK){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
@@ -194,7 +194,7 @@ ReturnValue_t Clock::getLeapSeconds(uint16_t* leapSeconds_) {
 	if(timeMutex==NULL){
 		return HasReturnvaluesIF::RETURN_FAILED;
 	}
-	ReturnValue_t result = timeMutex->lockMutex(MutexIF::NO_TIMEOUT);
+	ReturnValue_t result = timeMutex->lockMutex(MutexIF::BLOCKING);
 	if (result != HasReturnvaluesIF::RETURN_OK) {
 		return result;
 	}
diff --git a/osal/linux/Mutex.cpp b/osal/linux/Mutex.cpp
index dd8d3c5b..b27ff8c0 100644
--- a/osal/linux/Mutex.cpp
+++ b/osal/linux/Mutex.cpp
@@ -2,7 +2,6 @@
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 #include "../../timemanager/Clock.h"
 
-const uint32_t MutexIF::NO_TIMEOUT = 0;
 uint8_t Mutex::count = 0;
 
 
@@ -25,7 +24,9 @@ Mutex::Mutex() {
 		sif::error << "Mutex: creation with name, id " << mutex.__data.__count
 				<< ", " << " failed with " << strerror(status) << std::endl;
 	}
-	//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.
+	// 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) {
 		sif::error << "Mutex: Attribute destroy failed with " << strerror(status) << std::endl;
@@ -37,9 +38,13 @@ Mutex::~Mutex() {
 	pthread_mutex_destroy(&mutex);
 }
 
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType, uint32_t timeoutMs) {
 	int status = 0;
-	if (timeoutMs != MutexIF::NO_TIMEOUT) {
+
+	if(timeoutType == TimeoutType::POLLING) {
+	    status = pthread_mutex_trylock(&mutex);
+	}
+	else if (timeoutType == TimeoutType::WAITING) {
 		timespec timeOut;
 		clock_gettime(CLOCK_REALTIME, &timeOut);
 		uint64_t nseconds = timeOut.tv_sec * 1000000000 + timeOut.tv_nsec;
@@ -47,27 +52,35 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 		timeOut.tv_sec = nseconds / 1000000000;
 		timeOut.tv_nsec = nseconds - timeOut.tv_sec * 1000000000;
 		status = pthread_mutex_timedlock(&mutex, &timeOut);
-	} else {
+	}
+	else if(timeoutType == TimeoutType::BLOCKING) {
 		status = pthread_mutex_lock(&mutex);
 	}
+
 	switch (status) {
 	case EINVAL:
-		//The mutex was created with the protocol attribute having the value PTHREAD_PRIO_PROTECT and the calling thread's priority is higher than the mutex's current priority ceiling.
+		// The mutex was created with the protocol attribute having the value
+		// PTHREAD_PRIO_PROTECT and the calling thread's priority is higher
+		// than the mutex's current priority ceiling.
 		return WRONG_ATTRIBUTE_SETTING;
-		//The process or thread would have blocked, and the abs_timeout parameter specified a nanoseconds field value less than zero or greater than or equal to 1000 million.
-		//The value specified by mutex does not refer to an initialized mutex object.
+		// The process or thread would have blocked, and the abs_timeout
+		// parameter specified a nanoseconds field value less than zero or
+		// greater than or equal to 1000 million.
+		// The value specified by mutex does not refer to an initialized mutex object.
 		//return MUTEX_NOT_FOUND;
 	case EBUSY:
-		//The mutex could not be acquired because it was already locked.
+		// The mutex could not be acquired because it was already locked.
 		return MUTEX_ALREADY_LOCKED;
 	case ETIMEDOUT:
-		//The mutex could not be locked before the specified timeout expired.
+		// The mutex could not be locked before the specified timeout expired.
 		return MUTEX_TIMEOUT;
 	case EAGAIN:
-		//The mutex could not be acquired because the maximum number of recursive locks for mutex has been exceeded.
+		// The mutex could not be acquired because the maximum number of
+		// recursive locks for mutex has been exceeded.
 		return MUTEX_MAX_LOCKS;
 	case EDEADLK:
-		//A deadlock condition was detected or the current thread already owns the mutex.
+		// A deadlock condition was detected or the current thread
+		// already owns the mutex.
 		return CURR_THREAD_ALREADY_OWNS_MUTEX;
 	case 0:
 		//Success
diff --git a/osal/linux/Mutex.h b/osal/linux/Mutex.h
index 9f9bf521..ecb47a33 100644
--- a/osal/linux/Mutex.h
+++ b/osal/linux/Mutex.h
@@ -1,14 +1,15 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
+#ifndef OS_LINUX_MUTEX_H_
+#define OS_LINUX_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 #include <pthread.h>
 
+
 class Mutex : public MutexIF {
 public:
 	Mutex();
 	virtual ~Mutex();
-	virtual ReturnValue_t lockMutex(uint32_t timeoutMs);
+	virtual ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs);
 	virtual ReturnValue_t unlockMutex();
 private:
 	pthread_mutex_t mutex;
diff --git a/osal/linux/PeriodicPosixTask.cpp b/osal/linux/PeriodicPosixTask.cpp
index c08bb472..edf6bf23 100644
--- a/osal/linux/PeriodicPosixTask.cpp
+++ b/osal/linux/PeriodicPosixTask.cpp
@@ -22,7 +22,7 @@ void* PeriodicPosixTask::taskEntryPoint(void* arg) {
 }
 
 ReturnValue_t PeriodicPosixTask::addComponent(object_id_t object,
-        bool addTaskIF) {
+		bool addTaskIF) {
 	ExecutableObjectIF* newObject = objectManager->get<ExecutableObjectIF>(
 			object);
 	if (newObject == nullptr) {
diff --git a/osal/rtems/Mutex.cpp b/osal/rtems/Mutex.cpp
index d8babcde..9553ac79 100644
--- a/osal/rtems/Mutex.cpp
+++ b/osal/rtems/Mutex.cpp
@@ -1,7 +1,6 @@
 #include "Mutex.h"
 #include "../../serviceinterface/ServiceInterfaceStream.h"
 
-const uint32_t MutexIF::NO_TIMEOUT = RTEMS_NO_TIMEOUT;
 uint8_t Mutex::count = 0;
 
 Mutex::Mutex() :
@@ -24,8 +23,22 @@ Mutex::~Mutex() {
 	}
 }
 
-ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
-	rtems_status_code status = rtems_semaphore_obtain(mutexId, RTEMS_WAIT, timeoutMs);
+ReturnValue_t Mutex::lockMutex(TimeoutType timeoutType =
+        TimeoutType::BLOCKING, uint32_t timeoutMs) {
+	if(timeoutMs == MutexIF::TimeoutType::BLOCKING) {
+		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+				RTEMS_WAIT, RTEMS_NO_TIMEOUT);
+	}
+	else if(timeoutMs == MutexIF::TimeoutType::POLLING) {
+		timeoutMs = RTEMS_NO_TIMEOUT;
+		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+				RTEMS_NO_WAIT, 0);
+	}
+	else {
+		rtems_status_code status = rtems_semaphore_obtain(mutexId,
+				RTEMS_WAIT, timeoutMs);
+	}
+
 	switch(status){
 	case RTEMS_SUCCESSFUL:
 		//semaphore obtained successfully
diff --git a/osal/rtems/Mutex.h b/osal/rtems/Mutex.h
index 340bb16b..72368210 100644
--- a/osal/rtems/Mutex.h
+++ b/osal/rtems/Mutex.h
@@ -1,5 +1,5 @@
-#ifndef OS_RTEMS_MUTEX_H_
-#define OS_RTEMS_MUTEX_H_
+#ifndef FRAMEWORK_OSAL_RTEMS_MUTEX_H_
+#define FRAMEWORK_OSAL_RTEMS_MUTEX_H_
 
 #include "../../ipc/MutexIF.h"
 #include "RtemsBasic.h"
@@ -8,7 +8,7 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs);
+	ReturnValue_t lockMutex(TimeoutType timeoutType, uint32_t timeoutMs = 0);
 	ReturnValue_t unlockMutex();
 private:
 	rtems_id mutexId;
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 26eb2270..0e946b66 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -17,7 +17,7 @@ inline PoolManager<NUMBER_OF_POOLS>::~PoolManager(void) {
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::reserveSpace(
 		const uint32_t size, store_address_t* address, bool ignoreFault) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::reserveSpace(size,
 			address,ignoreFault);
 	return status;
@@ -29,7 +29,7 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 	// debug << "PoolManager( " << translateObject(getObjectId()) <<
 	//       " )::deleteData from store " << packet_id.pool_index <<
 	//       ". id is "<< packet_id.packet_index << std::endl;
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(packet_id);
 	return status;
 }
@@ -37,7 +37,7 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 		size_t size, store_address_t* storeId) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::deleteData(buffer,
 			size, storeId);
 	return status;
@@ -46,7 +46,7 @@ inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::deleteData(uint8_t* buffer,
 template<uint8_t NUMBER_OF_POOLS>
 inline ReturnValue_t PoolManager<NUMBER_OF_POOLS>::modifyData(
 		store_address_t packet_id, uint8_t** packet_ptr, size_t* size) {
-	MutexHelper mutexHelper(mutex,MutexIF::NO_TIMEOUT);
+	MutexHelper mutexHelper(mutex,MutexIF::BLOCKING);
 	ReturnValue_t status = LocalPool<NUMBER_OF_POOLS>::modifyData(packet_id,
 				packet_ptr, size);
 	return status;