diff --git a/datapoolglob/GlobalDataPool.cpp b/datapoolglob/GlobalDataPool.cpp
index e13765ba..18780904 100644
--- a/datapoolglob/GlobalDataPool.cpp
+++ b/datapoolglob/GlobalDataPool.cpp
@@ -54,7 +54,7 @@ ReturnValue_t GlobalDataPool::freeDataPoolLock() {
 }
 
 ReturnValue_t GlobalDataPool::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 bff15e3c..73e77e94 100644
--- a/events/EventManager.cpp
+++ b/events/EventManager.cpp
@@ -151,7 +151,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 94b7cf0b..5d9f5c61 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, uint32_t maxSize) {
-	mutex->lockMutex(MutexIF::NO_TIMEOUT);
+	mutex->lockMutex(MutexIF::BLOCKING);
 	size_t size = 0;
 	uint16_t count = healthMap.size();
 	ReturnValue_t result = SerializeAdapter<uint16_t>::serialize(&count,
@@ -85,7 +85,7 @@ void HealthTable::printAll(uint8_t* pointer, uint32_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 30a02b44..8944553d 100644
--- a/internalError/InternalErrorReporter.cpp
+++ b/internalError/InternalErrorReporter.cpp
@@ -53,7 +53,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();
@@ -62,21 +62,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();
@@ -85,14 +85,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();
 }
@@ -103,7 +103,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();
@@ -112,14 +112,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/osal/FreeRTOS/BinSemaphUsingTask.cpp b/osal/FreeRTOS/BinSemaphUsingTask.cpp
index 8f5fd4d8..d3351888 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/BinSemaphUsingTask.cpp
@@ -17,11 +17,11 @@ BinarySemaphoreUsingTask::~BinarySemaphoreUsingTask() {
 }
 
 ReturnValue_t BinarySemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
-		timeout = SemaphoreIF::MAX_TIMEOUT;
+	TickType_t timeout = SemaphoreIF::POLLING;
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
+		timeout = SemaphoreIF::BLOCKING;
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 	return acquireWithTickTimeout(timeout);
diff --git a/osal/FreeRTOS/BinSemaphUsingTask.h b/osal/FreeRTOS/BinSemaphUsingTask.h
index 48c1cd12..43772e5a 100644
--- a/osal/FreeRTOS/BinSemaphUsingTask.h
+++ b/osal/FreeRTOS/BinSemaphUsingTask.h
@@ -26,7 +26,7 @@ public:
 	virtual~ BinarySemaphoreUsingTask();
 
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	        SemaphoreIF::NO_TIMEOUT) override;
+	        SemaphoreIF::BLOCKING) override;
 	ReturnValue_t release() override;
 	uint8_t getSemaphoreCounter() const override;
 	static uint8_t getSemaphoreCounter(TaskHandle_t taskHandle);
@@ -40,7 +40,7 @@ public:
 	 *         - @c RETURN_FAILED on failure
 	 */
 	ReturnValue_t acquireWithTickTimeout(TickType_t timeoutTicks =
-	        SemaphoreIF::NO_TIMEOUT);
+	        SemaphoreIF::BLOCKING);
 
 	/**
 	 * Get handle to the task related to the semaphore.
diff --git a/osal/FreeRTOS/BinarySemaphore.cpp b/osal/FreeRTOS/BinarySemaphore.cpp
index b6687bb7..e6d2f92f 100644
--- a/osal/FreeRTOS/BinarySemaphore.cpp
+++ b/osal/FreeRTOS/BinarySemaphore.cpp
@@ -36,11 +36,11 @@ BinarySemaphore& BinarySemaphore::operator =(
 }
 
 ReturnValue_t BinarySemaphore::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
-	    timeout = SemaphoreIF::MAX_TIMEOUT;
+	TickType_t timeout = SemaphoreIF::POLLING;
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
+	    timeout = SemaphoreIF::BLOCKING;
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 	    timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 	return acquireWithTickTimeout(timeout);
diff --git a/osal/FreeRTOS/BinarySemaphore.h b/osal/FreeRTOS/BinarySemaphore.h
index 0938dee6..2a372cd2 100644
--- a/osal/FreeRTOS/BinarySemaphore.h
+++ b/osal/FreeRTOS/BinarySemaphore.h
@@ -53,7 +53,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquire(uint32_t timeoutMs =
-	       	   SemaphoreIF::NO_TIMEOUT) override;
+			SemaphoreIF::BLOCKING) override;
 
 	/**
 	 * Same as lockBinarySemaphore() with timeout in FreeRTOS ticks.
@@ -62,7 +62,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t  acquireWithTickTimeout(TickType_t timeoutTicks =
-	        BinarySemaphore::NO_TIMEOUT);
+			SemaphoreIF::BLOCKING);
 
 	/**
 	 * Release the binary semaphore.
diff --git a/osal/FreeRTOS/Clock.cpp b/osal/FreeRTOS/Clock.cpp
index dce20265..ec07b662 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/CountingSemaphUsingTask.cpp b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
index d0f63f3f..f33c7a0d 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.cpp
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.cpp
@@ -38,11 +38,11 @@ CountingSemaphoreUsingTask::~CountingSemaphoreUsingTask() {
 }
 
 ReturnValue_t CountingSemaphoreUsingTask::acquire(uint32_t timeoutMs) {
-	TickType_t timeout = SemaphoreIF::NO_TIMEOUT;
-	if(timeoutMs == SemaphoreIF::MAX_TIMEOUT) {
-		timeout = SemaphoreIF::MAX_TIMEOUT;
+	TickType_t timeout = SemaphoreIF::POLLING;
+	if(timeoutMs == SemaphoreIF::BLOCKING) {
+		timeout = SemaphoreIF::BLOCKING;
 	}
-	else if(timeoutMs > SemaphoreIF::NO_TIMEOUT){
+	else if(timeoutMs > SemaphoreIF::POLLING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 	return acquireWithTickTimeout(timeout);
diff --git a/osal/FreeRTOS/CountingSemaphUsingTask.h b/osal/FreeRTOS/CountingSemaphUsingTask.h
index 797e864b..f1d82c1d 100644
--- a/osal/FreeRTOS/CountingSemaphUsingTask.h
+++ b/osal/FreeRTOS/CountingSemaphUsingTask.h
@@ -31,7 +31,7 @@ public:
 	 * @return -@c RETURN_OK on success
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
-	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::NO_TIMEOUT) override;
+	ReturnValue_t acquire(uint32_t timeoutMs = SemaphoreIF::BLOCKING) override;
 
 	/**
 	 * Release a semaphore, increasing the number of available counting
@@ -61,7 +61,7 @@ public:
 	 *         -@c SemaphoreIF::SEMAPHORE_TIMEOUT on timeout
 	 */
 	ReturnValue_t acquireWithTickTimeout(
-			TickType_t timeoutTicks = SemaphoreIF::NO_TIMEOUT);
+			TickType_t timeoutTicks = SemaphoreIF::BLOCKING);
 
 	/**
 	 * Get handle to the task related to the semaphore.
diff --git a/osal/FreeRTOS/Mutex.cpp b/osal/FreeRTOS/Mutex.cpp
index cc2f865f..6d90c3f6 100644
--- a/osal/FreeRTOS/Mutex.cpp
+++ b/osal/FreeRTOS/Mutex.cpp
@@ -2,8 +2,8 @@
 
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
-const uint32_t MutexIF::NO_TIMEOUT = 0;
-const uint32_t MutexIF::MAX_TIMEOUT = portMAX_DELAY;
+const uint32_t MutexIF::POLLING = 0;
+const uint32_t MutexIF::BLOCKING = portMAX_DELAY;
 
 Mutex::Mutex() {
 	handle = xSemaphoreCreateMutex();
@@ -23,11 +23,11 @@ ReturnValue_t Mutex::lockMutex(uint32_t timeoutMs) {
 	if (handle == nullptr) {
 		return MutexIF::MUTEX_NOT_FOUND;
 	}
-	TickType_t timeout = MutexIF::NO_TIMEOUT;
-	if(timeoutMs == MutexIF::MAX_TIMEOUT) {
-		timeout = MutexIF::MAX_TIMEOUT;
+	TickType_t timeout = MutexIF::POLLING;
+	if(timeoutMs == MutexIF::BLOCKING) {
+		timeout = MutexIF::BLOCKING;
 	}
-	else if(timeoutMs > MutexIF::NO_TIMEOUT){
+	else if(timeoutMs > MutexIF::POLLING){
 		timeout = pdMS_TO_TICKS(timeoutMs);
 	}
 
diff --git a/osal/FreeRTOS/Mutex.h b/osal/FreeRTOS/Mutex.h
index 90e82467..d6e0aab9 100644
--- a/osal/FreeRTOS/Mutex.h
+++ b/osal/FreeRTOS/Mutex.h
@@ -18,7 +18,7 @@ class Mutex : public MutexIF {
 public:
 	Mutex();
 	~Mutex();
-	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::MAX_TIMEOUT) override;
+	ReturnValue_t lockMutex(uint32_t timeoutMs = MutexIF::BLOCKING) override;
 	ReturnValue_t unlockMutex() override;
 private:
 	SemaphoreHandle_t handle;
diff --git a/osal/FreeRTOS/SemaphoreFactory.cpp b/osal/FreeRTOS/SemaphoreFactory.cpp
index 05a898cd..caf984f2 100644
--- a/osal/FreeRTOS/SemaphoreFactory.cpp
+++ b/osal/FreeRTOS/SemaphoreFactory.cpp
@@ -6,8 +6,8 @@
 #include <framework/serviceinterface/ServiceInterfaceStream.h>
 
 SemaphoreFactory* SemaphoreFactory::factoryInstance = nullptr;
-const uint32_t SemaphoreIF::NO_TIMEOUT = 0;
-const uint32_t SemaphoreIF::MAX_TIMEOUT = portMAX_DELAY;
+const uint32_t SemaphoreIF::POLLING= 0;
+const uint32_t SemaphoreIF::BLOCKING = portMAX_DELAY;
 
 static const uint32_t USE_REGULAR_SEMAPHORES = 0;
 static const uint32_t USE_TASK_NOTIFICATIONS = 1;
diff --git a/storagemanager/PoolManager.tpp b/storagemanager/PoolManager.tpp
index 29b2b82a..9fb11776 100644
--- a/storagemanager/PoolManager.tpp
+++ b/storagemanager/PoolManager.tpp
@@ -21,7 +21,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;
@@ -33,7 +33,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;
 }
@@ -41,7 +41,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;